void Qjets::Cluster(fastjet::ClusterSequence & cs){
ComputeDCut(cs);
ComputeAllDistances(cs.jets());
while (!_distances.empty()){
double dmin = ComputeMinimumDistance();
double norm = ComputeNormalization(dmin);
// sometimes if the rigidity is too large the norm is zero. make sure this is not the case
if(_distances.size() == 0)
break;
assert(norm > 0.);
// Now compute a random number between 0 and 1 and find the corresponding measure
double rand = Rand();
double sum = 0.;
for(list<jet_distance>::iterator it = _distances.begin(); it != _distances.end(); it++){
/*
We need to be careful about dmin == 0 which happens for collinear jets.
(Thanks go to Nhan V Tran for finding this bug)
*/
if(dmin == 0.){
if((*it).dij == 0.)
sum += 1./norm;
} else
sum += exp(-_rigidity*((*it).dij-dmin)/dmin)/norm;
assert(!isnan((float)sum));
if(sum > rand){
if(!Prune((*it),cs)){
_merged_jets.push_back((*it).j1);
_merged_jets.push_back((*it).j2);
int new_jet;
cs.plugin_record_ij_recombination((*it).j1, (*it).j2, 1., new_jet);
assert(JetUnmerged(new_jet));
ComputeNewDistanceMeasures(cs,new_jet);
} else {
double j1pt = cs.jets()[(*it).j1].perp();
double j2pt = cs.jets()[(*it).j2].perp();
if(j1pt>j2pt){
_merged_jets.push_back((*it).j2);
cs.plugin_record_iB_recombination((*it).j2, 1.);
} else {
_merged_jets.push_back((*it).j1);
cs.plugin_record_iB_recombination((*it).j1, 1.);
}
}
break;
}
}
}
// merge remaining jets with beam
int num_merged_final(0);
for(unsigned int i = 0 ; i < cs.jets().size(); i++)
if(JetUnmerged(i)){
num_merged_final++;
cs.plugin_record_iB_recombination(i,1.);
}
assert(num_merged_final < 2);
}
void
addtrans(Graph *col, char *from, Node *op, char *to)
{ State *b;
Transition *t;
t = (Transition *) tl_emalloc(sizeof(Transition));
t->name = tl_lookup(to);
t->cond = Prune(dupnode(op));
if (tl_verbose)
{ printf("\n%s <<\t", from); dump(op);
printf("\n\t"); dump(t->cond);
printf(">> %s\n", t->name->name);
}
if (t->cond) t->cond = rewrite(t->cond);
for (b = never; b; b = b->nxt)
if (!strcmp(b->name->name, from))
{ t->nxt = b->trans;
b->trans = t;
return;
}
b = (State *) tl_emalloc(sizeof(State));
b->name = tl_lookup(from);
b->colors = col;
b->trans = t;
if (!strncmp(from, "accept", 6))
b->accepting = 1;
b->nxt = never;
never = b;
}
void MRUManager::Add(std::string const& key, std::string const& entry) {
MRUListMap &map = Find(key);
map.remove(entry);
map.push_front(entry);
Prune(key, map);
Flush();
}
/// @brief Load MRU Lists.
/// @param key List name.
/// @param array json::Array of values.
void MRUManager::Load(std::string const& key, const json::Array& array) {
try {
copy(array.begin(), array.end(), back_inserter(mru[key]));
}
catch (json::Exception const&) {
// Out of date MRU file; just discard the data and skip it
}
Prune(key, mru[key]);
}
static SEXP Prune(SEXP lst)
{
if (lst == R_NilValue)
return lst;
SETCDR(lst, Prune(CDR(lst)));
if (CAR(lst) == R_MissingArg)
return CDR(lst);
else return lst ;
}
void PartialTranslOptColl::Add(const TranslationSystem* system, TranslationOption *partialTranslOpt)
{
// add
AddNoPrune(system,partialTranslOpt );
// done if not too large (lazy pruning, only if twice as large as max)
if ( m_list.size() > 2 * m_maxSize ) {
Prune();
}
}
void WhoWas::Manager::UpdateConfig(unsigned int NewGroupSize, unsigned int NewMaxGroups, unsigned int NewMaxKeep)
{
if ((NewGroupSize == GroupSize) && (NewMaxGroups == MaxGroups) && (NewMaxKeep == MaxKeep))
return;
GroupSize = NewGroupSize;
MaxGroups = NewMaxGroups;
MaxKeep = NewMaxKeep;
Prune();
}
BOOL CLibraryHistory::Submit(CLibraryFile* pFile)
{
CLibraryRecent* pRecent = GetByPath( pFile->GetPath() );
if ( pRecent == NULL ) return FALSE;
pRecent->RunVerify( pFile );
Prune();
return TRUE;
}
static Node *
Prune(Node *p)
{
if (p)
switch (p->ntyp) {
case PREDICATE:
case NOT:
case FALSE:
case TRUE:
#ifdef NXT
case NEXT:
#endif
return p;
case OR:
p->lft = Prune(p->lft);
if (!p->lft)
{ releasenode(1, p->rgt);
return ZN;
}
p->rgt = Prune(p->rgt);
if (!p->rgt)
{ releasenode(1, p->lft);
return ZN;
}
return p;
case AND:
p->lft = Prune(p->lft);
if (!p->lft)
return Prune(p->rgt);
p->rgt = Prune(p->rgt);
if (!p->rgt)
return p->lft;
return p;
}
releasenode(1, p);
return ZN;
}
CLibraryRecent* CLibraryHistory::Add(LPCTSTR pszPath, const SHA1* pSHA1, const MD4* pED2K, LPCTSTR pszSources)
{
CSingleLock pLock( &Library.m_pSection );
if ( ! pLock.Lock( 500 ) ) return NULL;
CLibraryRecent* pRecent = GetByPath( pszPath );
if ( pRecent != NULL ) return pRecent;
pRecent = new CLibraryRecent( pszPath, pSHA1, pED2K, pszSources );
m_pList.AddHead( pRecent );
Prune();
return pRecent;
}
void TranslationOptionCollectionLattice::CreateTranslationOptions()
{
GetTargetPhraseCollectionBatch();
VERBOSE(2,"Translation Option Collection\n " << *this << endl);
const vector <DecodeGraph*> &decodeGraphs = StaticData::Instance().GetDecodeGraphs();
UTIL_THROW_IF2(decodeGraphs.size() != 1, "Multiple decoder graphs not supported yet");
const DecodeGraph &decodeGraph = *decodeGraphs[0];
UTIL_THROW_IF2(decodeGraph.GetSize() != 1, "Factored decomposition not supported yet");
const DecodeStep &decodeStep = **decodeGraph.begin();
const PhraseDictionary &phraseDictionary = *decodeStep.GetPhraseDictionaryFeature();
for (size_t i = 0; i < m_inputPathQueue.size(); ++i) {
const InputPath &path = *m_inputPathQueue[i];
const TargetPhraseCollection *tpColl = path.GetTargetPhrases(phraseDictionary);
const WordsRange &range = path.GetWordsRange();
if (tpColl) {
TargetPhraseCollection::const_iterator iter;
for (iter = tpColl->begin(); iter != tpColl->end(); ++iter) {
const TargetPhrase &tp = **iter;
TranslationOption *transOpt = new TranslationOption(range, tp);
transOpt->SetInputPath(path);
transOpt->Evaluate(m_source);
Add(transOpt);
}
}
else if (path.GetPhrase().GetSize() == 1) {
// unknown word processing
ProcessOneUnknownWord(path, path.GetWordsRange().GetEndPos(), 1, path.GetInputScore());
}
}
// Prune
Prune();
Sort();
// future score matrix
CalcFutureScore();
// Cached lex reodering costs
CacheLexReordering();
}
void FuseRegions(cl_float sigmaS, cl_int minRegion)
{
//allocate memory visit table
visitTable = new cl_uchar [L];
//Apply transitive closure iteratively to the regions classified
//by the RAM updating labels and modes until the color of each neighboring
//region is within sqrt(rR2) of one another.
rR2 = (cl_float)(sigmaS*sigmaS*0.25);
TransitiveClosure();
cl_int oldRC = regionCount;
cl_int deltaRC, counter = 0;
do {
TransitiveClosure();
deltaRC = oldRC-regionCount;
oldRC = regionCount;
counter++;
} while ((deltaRC <= 0)&&(counter < 10));
//de-allocate memory for visit table
delete [] visitTable;
visitTable = NULL;
//Prune spurious regions (regions whose area is under
//minRegion) using RAM
Prune(minRegion);
//de-allocate memory for region adjacency matrix
DestroyRAM();
//output to h_dst
cl_int label;
for(cl_uint i = 0; i < L; i++)
{
label = labels[i];
h_dst[i][0] = modes[N*label+0];
h_dst[i][1] = modes[N*label+1];
h_dst[i][2] = modes[N*label+2];
}
//done.
return;
}
VNode* DESPOT::Prune(VNode* vnode, int& pruned_action, double& pruned_value) {
vector<State*> empty;
VNode* pruned_v = new VNode(empty, vnode->depth(), NULL,
vnode->edge());
vector<QNode*>& children = vnode->children();
int astar = -1;
double nustar = Globals::NEG_INFTY;
QNode* qstar = NULL;
for (int i = 0; i < children.size(); i++) {
QNode* qnode = children[i];
double nu;
QNode* pruned_q = Prune(qnode, nu);
if (nu > nustar) {
nustar = nu;
astar = qnode->edge();
if (qstar != NULL) {
delete qstar;
}
qstar = pruned_q;
} else {
delete pruned_q;
}
}
if (nustar < vnode->default_move().value) {
nustar = vnode->default_move().value;
astar = vnode->default_move().action;
delete qstar;
} else {
pruned_v->children().push_back(qstar);
qstar->parent(pruned_v);
}
pruned_v->lower_bound(vnode->lower_bound()); // for debugging
pruned_v->upper_bound(vnode->upper_bound());
pruned_action = astar;
pruned_value = nustar;
return pruned_v;
}
void EHUD::TimeStep()
{
HUDEVENT * ev;
for (int i = 0; i < events.size(); i++)
{
if (!events[i])
continue;
ev = events[i];
if (!isNull(ev->From))
{
if (!isFocus(ev->From))
continue;
}
oapiAnnotationSetText(ev->hNote,ev->Ann->msg);
}
Prune();
}
void Qjets::Cluster(fastjet::ClusterSequence & cs){
ComputeDCut(cs);
// Populate all the distances
ComputeAllDistances(cs.jets());
jet_distance jd = GetNextDistance();
while(!_distances.empty() && jd.dij != -1.){
if(!Prune(jd,cs)){
// _merged_jets.push_back(jd.j1);
// _merged_jets.push_back(jd.j2);
_merged_jets[jd.j1] = true;
_merged_jets[jd.j2] = true;
int new_jet;
cs.plugin_record_ij_recombination(jd.j1, jd.j2, 1., new_jet);
assert(JetUnmerged(new_jet));
ComputeNewDistanceMeasures(cs,new_jet);
} else {
double j1pt = cs.jets()[jd.j1].perp();
double j2pt = cs.jets()[jd.j2].perp();
if(j1pt>j2pt){
// _merged_jets.push_back(jd.j2);
_merged_jets[jd.j2] = true;
cs.plugin_record_iB_recombination(jd.j2, 1.);
} else {
// _merged_jets.push_back(jd.j1);
_merged_jets[jd.j1] = true;
cs.plugin_record_iB_recombination(jd.j1, 1.);
}
}
jd = GetNextDistance();
}
// merge remaining jets with beam
int num_merged_final(0);
for(unsigned int i = 0 ; i < cs.jets().size(); i++)
if(JetUnmerged(i)){
num_merged_final++;
cs.plugin_record_iB_recombination(i,1.);
}
}
/**
* @brief Internal function to write new line to log-file.
* @param [in] msg Message to add to log-file.
*/
void CLogFile::WriteRaw(LPCTSTR msg)
{
DWORD dwWaitRes = WaitForSingleObject(m_hLogMutex, 10000);
if (dwWaitRes == WAIT_OBJECT_0)
{
FILE *f;
if ((f=_tfopen(m_strLogPath.c_str(), _T("a"))) != NULL)
{
_fputts(msg, f);
// prune the log if it gets too big
if (ftell(f) >= (int)m_nMaxSize)
Prune(f);
else
fclose(f);
}
ReleaseMutex(m_hLogMutex);
}
}
void SuffixTree<Symb,NSymb>::Prune(PNode n, bool cut)
{
SetCut(n, cut);
PNode ch = GetNode(n).child;
if(ch == NIL) return;
bool invalid = false;
if(!cut) {
invalid = !IsValid(n);
cut = invalid;
}
// TODO: safety - remove recursion in this and other methods
// recursion
do {
Prune(ch, cut);
ch = NxtChild(ch);
} while(ch != NIL);
if(invalid) GetNode(n).child = NIL; // physically cut off children (but without destroying them)
}
QNode* DESPOT::Prune(QNode* qnode, double& pruned_value) {
QNode* pruned_q = new QNode((VNode*) NULL, qnode->edge());
pruned_value = qnode->step_reward - Globals::config.pruning_constant;
map<OBS_TYPE, VNode*>& children = qnode->children();
for (map<OBS_TYPE, VNode*>::iterator it = children.begin();
it != children.end(); it++) {
int astar;
double nu;
VNode* pruned_v = Prune(it->second, astar, nu);
if (nu == it->second->default_move().value) {
delete pruned_v;
} else {
pruned_q->children()[it->first] = pruned_v;
pruned_v->parent(pruned_q);
}
pruned_value += nu;
}
pruned_q->lower_bound(qnode->lower_bound()); // for debugging
pruned_q->upper_bound(qnode->upper_bound()); // for debugging
return pruned_q;
}
/// @brief Load MRU Lists.
/// @param key List name.
/// @param array json::Array of values.
void MRUManager::Load(const std::string &key, const json::Array& array) {
transform(array.Begin(), array.End(), back_inserter(mru[key]), cast_str);
Prune(mru[key]);
}
void MRUManager::Add(const std::string &key, const std::string &entry) {
MRUListMap &map = Find(key);
map.remove(entry);
map.push_front(entry);
Prune(map);
}
double DESPOT::CheckDESPOT(const VNode* vnode, double regularized_value) {
cout
<< "--------------------------------------------------------------------------------"
<< endl;
const vector<State*>& particles = vnode->particles();
vector<State*> copy;
for (int i = 0; i < particles.size(); i ++) {
copy.push_back(model_->Copy(particles[i]));
}
VNode* root = new VNode(copy);
double pruning_constant = Globals::config.pruning_constant;
Globals::config.pruning_constant = 0;
RandomStreams streams = RandomStreams(Globals::config.num_scenarios,
Globals::config.search_depth);
streams.position(0);
InitBounds(root, lower_bound_, upper_bound_, streams, history_);
double used_time = 0;
int num_trials = 0, prev_num = 0;
double pruned_value;
do {
double start = clock();
VNode* cur = Trial(root, streams, lower_bound_, upper_bound_, model_, history_);
num_trials++;
used_time += double(clock() - start) / CLOCKS_PER_SEC;
start = clock();
Backup(cur);
used_time += double(clock() - start) / CLOCKS_PER_SEC;
if (double(num_trials - prev_num) > 0.05 * prev_num) {
int pruned_action;
Globals::config.pruning_constant = pruning_constant;
VNode* pruned = Prune(root, pruned_action, pruned_value);
Globals::config.pruning_constant = 0;
prev_num = num_trials;
pruned->Free(*model_);
delete pruned;
cout << "# trials = " << num_trials << "; target = "
<< regularized_value << ", current = " << pruned_value
<< ", l = " << root->lower_bound() << ", u = "
<< root->upper_bound() << "; time = " << used_time << endl;
if (pruned_value >= regularized_value) {
break;
}
}
} while (true);
cout << "DESPOT: # trials = " << num_trials << "; target = "
<< regularized_value << ", current = " << pruned_value << ", l = "
<< root->lower_bound() << ", u = " << root->upper_bound() << "; time = "
<< used_time << endl;
Globals::config.pruning_constant = pruning_constant;
cout
<< "--------------------------------------------------------------------------------"
<< endl;
root->Free(*model_);
delete root;
return used_time;
}
DLLCLBK void opcPreStep(double simt, double simdt, double mjd)
{
Prune();
UPM.TimeStep();
}
SEXP deriv(SEXP args)
{
/* deriv(expr, namevec, function.arg, tag, hessian) */
SEXP ans, ans2, expr, funarg, names, s;
int f_index, *d_index, *d2_index;
int i, j, k, nexpr, nderiv=0, hessian;
SEXP exprlist, tag;
args = CDR(args);
InitDerivSymbols();
PROTECT(exprlist = LCONS(R_BraceSymbol, R_NilValue));
/* expr: */
if (isExpression(CAR(args)))
PROTECT(expr = VECTOR_ELT(CAR(args), 0));
else PROTECT(expr = CAR(args));
args = CDR(args);
/* namevec: */
names = CAR(args);
if (!isString(names) || (nderiv = length(names)) < 1)
error(_("invalid variable names"));
args = CDR(args);
/* function.arg: */
funarg = CAR(args);
args = CDR(args);
/* tag: */
tag = CAR(args);
if (!isString(tag) || length(tag) < 1
|| length(STRING_ELT(tag, 0)) < 1 || length(STRING_ELT(tag, 0)) > 60)
error(_("invalid tag"));
args = CDR(args);
/* hessian: */
hessian = asLogical(CAR(args));
/* NOTE: FindSubexprs is destructive, hence the duplication.
It can allocate, so protect the duplicate.
*/
PROTECT(ans = duplicate(expr));
f_index = FindSubexprs(ans, exprlist, tag);
d_index = (int*)R_alloc((size_t) nderiv, sizeof(int));
if (hessian)
d2_index = (int*)R_alloc((size_t) ((nderiv * (1 + nderiv))/2),
sizeof(int));
else d2_index = d_index;/*-Wall*/
UNPROTECT(1);
for(i=0, k=0; i<nderiv ; i++) {
PROTECT(ans = duplicate(expr));
PROTECT(ans = D(ans, installTrChar(STRING_ELT(names, i))));
PROTECT(ans2 = duplicate(ans)); /* keep a temporary copy */
d_index[i] = FindSubexprs(ans, exprlist, tag); /* examine the derivative first */
PROTECT(ans = duplicate(ans2)); /* restore the copy */
if (hessian) {
for(j = i; j < nderiv; j++) {
PROTECT(ans2 = duplicate(ans)); /* install could allocate */
PROTECT(ans2 = D(ans2, installTrChar(STRING_ELT(names, j))));
d2_index[k] = FindSubexprs(ans2, exprlist, tag);
k++;
UNPROTECT(2);
}
}
UNPROTECT(4);
}
nexpr = length(exprlist) - 1;
if (f_index) {
Accumulate2(MakeVariable(f_index, tag), exprlist);
}
else {
PROTECT(ans = duplicate(expr));
Accumulate2(expr, exprlist);
UNPROTECT(1);
}
Accumulate2(R_NilValue, exprlist);
if (hessian) { Accumulate2(R_NilValue, exprlist); }
for (i = 0, k = 0; i < nderiv ; i++) {
if (d_index[i]) {
Accumulate2(MakeVariable(d_index[i], tag), exprlist);
if (hessian) {
PROTECT(ans = duplicate(expr));
PROTECT(ans = D(ans, installTrChar(STRING_ELT(names, i))));
for (j = i; j < nderiv; j++) {
if (d2_index[k]) {
Accumulate2(MakeVariable(d2_index[k], tag), exprlist);
} else {
PROTECT(ans2 = duplicate(ans));
PROTECT(ans2 = D(ans2, installTrChar(STRING_ELT(names, j))));
Accumulate2(ans2, exprlist);
UNPROTECT(2);
}
k++;
}
UNPROTECT(2);
}
} else { /* the first derivative is constant or simple variable */
PROTECT(ans = duplicate(expr));
PROTECT(ans = D(ans, installTrChar(STRING_ELT(names, i))));
Accumulate2(ans, exprlist);
UNPROTECT(2);
if (hessian) {
for (j = i; j < nderiv; j++) {
if (d2_index[k]) {
Accumulate2(MakeVariable(d2_index[k], tag), exprlist);
} else {
PROTECT(ans2 = duplicate(ans));
PROTECT(ans2 = D(ans2, installTrChar(STRING_ELT(names, j))));
if(isZero(ans2)) Accumulate2(R_MissingArg, exprlist);
else Accumulate2(ans2, exprlist);
UNPROTECT(2);
}
k++;
}
}
}
}
Accumulate2(R_NilValue, exprlist);
Accumulate2(R_NilValue, exprlist);
if (hessian) { Accumulate2(R_NilValue, exprlist); }
i = 0;
ans = CDR(exprlist);
while (i < nexpr) {
if (CountOccurrences(MakeVariable(i+1, tag), CDR(ans)) < 2) {
SETCDR(ans, Replace(MakeVariable(i+1, tag), CAR(ans), CDR(ans)));
SETCAR(ans, R_MissingArg);
}
else {
SEXP var;
PROTECT(var = MakeVariable(i+1, tag));
SETCAR(ans, lang3(install("<-"), var, AddParens(CAR(ans))));
UNPROTECT(1);
}
i = i + 1;
ans = CDR(ans);
}
/* .value <- ... */
SETCAR(ans, lang3(install("<-"), install(".value"), AddParens(CAR(ans))));
ans = CDR(ans);
/* .grad <- ... */
SETCAR(ans, CreateGrad(names));
ans = CDR(ans);
/* .hessian <- ... */
if (hessian) { SETCAR(ans, CreateHess(names)); ans = CDR(ans); }
/* .grad[, "..."] <- ... */
for (i = 0; i < nderiv ; i++) {
SETCAR(ans, DerivAssign(STRING_ELT(names, i), AddParens(CAR(ans))));
ans = CDR(ans);
if (hessian) {
for (j = i; j < nderiv; j++) {
if (CAR(ans) != R_MissingArg) {
if (i == j) {
SETCAR(ans, HessAssign1(STRING_ELT(names, i),
AddParens(CAR(ans))));
} else {
SETCAR(ans, HessAssign2(STRING_ELT(names, i),
STRING_ELT(names, j),
AddParens(CAR(ans))));
}
}
ans = CDR(ans);
}
}
}
/* attr(.value, "gradient") <- .grad */
SETCAR(ans, AddGrad());
ans = CDR(ans);
if (hessian) { SETCAR(ans, AddHess()); ans = CDR(ans); }
/* .value */
SETCAR(ans, install(".value"));
/* Prune the expression list removing eliminated sub-expressions */
SETCDR(exprlist, Prune(CDR(exprlist)));
if (TYPEOF(funarg) == LGLSXP && LOGICAL(funarg)[0]) { /* fun = TRUE */
funarg = names;
}
if (TYPEOF(funarg) == CLOSXP)
{
funarg = mkCLOSXP(FORMALS(funarg), exprlist, CLOENV(funarg));
}
else if (isString(funarg)) {
SEXP formals = allocList(length(funarg));
ans = formals;
for(i = 0; i < length(funarg); i++) {
SET_TAG(ans, installTrChar(STRING_ELT(funarg, i)));
SETCAR(ans, R_MissingArg);
ans = CDR(ans);
}
funarg = mkCLOSXP(formals, exprlist, R_GlobalEnv);
}
else {
funarg = allocVector(EXPRSXP, 1);
SET_VECTOR_ELT(funarg, 0, exprlist);
/* funarg = lang2(install("expression"), exprlist); */
}
UNPROTECT(2);
return funarg;
}
void IWeights::Prune(const Mesh &mesh, const MEField<> *mask) {
Prune(mesh,&*mask);
}