/** * Create a function from an expression. * @param expr :: The input expression * @param parentAttributes :: An output map filled with the attribute name & * values of the parent function * @return A pointer to the created function */ IFunction_sptr FunctionFactoryImpl::createSimple( const Expression &expr, std::map<std::string, std::string> &parentAttributes) const { if (expr.name() == "=" && expr.size() > 1) { return createFunction(expr.terms()[1].name()); } if (expr.name() != "," || expr.size() == 0) { inputError(expr.str()); } const std::vector<Expression> &terms = expr.terms(); auto term = terms.cbegin(); if (term->name() != "=") inputError(expr.str()); if (term->terms()[0].name() != "name" && term->terms()[0].name() != "composite") { throw std::invalid_argument( "Function name must be defined before its parameters"); } std::string fnName = term->terms()[1].name(); IFunction_sptr fun = createFunction(fnName); for (++term; term != terms.end(); ++term) { // loop over function's parameters/attributes if (term->name() != "=") inputError(expr.str()); std::string parName = term->terms()[0].name(); std::string parValue = term->terms()[1].str(); if (fun->hasAttribute(parName)) { // set attribute if (parValue.size() > 1 && parValue[0] == '"') { // remove the double quotes parValue = parValue.substr(1, parValue.size() - 2); } IFunction::Attribute att = fun->getAttribute(parName); att.fromString(parValue); fun->setAttribute(parName, att); } else if (parName.size() >= 10 && parName.substr(0, 10) == "constraint") { // or it can be a list of constraints addConstraints(fun, (*term)[1]); } else if (parName == "ties") { addTies(fun, (*term)[1]); } else if (!parName.empty() && parName[0] == '$') { parName.erase(0, 1); parentAttributes[parName] = parValue; } else { // set initial parameter value fun->setParameter(parName, atof(parValue.c_str())); } } // for term fun->applyTies(); return fun; }
vguard<set<Ontology::TermIndex> > Ontology::transitiveClosure() const { vguard<set<TermIndex> > tc (terms()); auto L = toposortTermIndex(); for (TermIndex n : L) { tc[n].insert (n); for (TermIndex p : parents[n]) tc[n].insert (tc[p].begin(), tc[p].end()); } return tc; }
static void listdevices() { netlist_tool_t nt; nt.init(); const netlist::factory_list_t::list_t &list = nt.setup().factory().list(); nt.setup().register_source(palloc(netlist::source_proc_t, "dummy", &netlist_dummy)); nt.setup().include("dummy"); nt.setup().start_devices(); nt.setup().resolve_inputs(); for (int i=0; i < list.size(); i++) { pstring out = pstring::sprintf("%-20s %s(<id>", list[i]->classname().cstr(), list[i]->name().cstr() ); pstring terms(""); netlist::base_factory_t *f = list[i]; netlist::device_t *d = f->Create(); d->init(nt, pstring::sprintf("dummy%d", i)); d->start_dev(); // get the list of terminals ... for (int j=0; j < d->m_terminals.size(); j++) { pstring inp = d->m_terminals[j]; if (inp.startsWith(d->name() + ".")) inp = inp.substr(d->name().len() + 1); terms += "," + inp; } if (list[i]->param_desc().startsWith("+")) { out += "," + list[i]->param_desc().substr(1); terms = ""; } else if (list[i]->param_desc() == "-") { /* no params at all */ } else { out += "," + list[i]->param_desc(); } out += ")"; printf("%s\n", out.cstr()); if (terms != "") printf("Terminals: %s\n", terms.substr(1).cstr()); } }
TermInfosReaderThreadResourcesPtr TermInfosReader::getThreadResources() { TermInfosReaderThreadResourcesPtr resources(threadResources.get()); if (!resources) { resources = newLucene<TermInfosReaderThreadResources>(); resources->termEnum = terms(); // Cache does not have to be thread-safe, it is only used by one thread at the same time resources->termInfoCache = newInstance<TermInfoCache>(DEFAULT_CACHE_SIZE); threadResources.set(resources); } return resources; }
void tool_app_t::listdevices() { netlist_tool_t nt(*this, "netlist"); nt.init(); nt.log().verbose.set_enabled(false); nt.log().info.set_enabled(false); nt.log().warning.set_enabled(false); netlist::factory::list_t &list = nt.setup().factory(); nt.setup().register_source(plib::make_unique<netlist::source_proc_t>("dummy", &netlist_dummy)); nt.setup().include("dummy"); nt.setup().prepare_to_run(); std::vector<netlist::pool_owned_ptr<netlist::core_device_t>> devs; for (auto & f : list) { pstring out = plib::pfmt("{1:-20} {2}(<id>")(f->classname())(f->name()); f->macro_actions(nt.setup(), f->name() + "_lc"); auto d = f->Create(nt.nlstate(), f->name() + "_lc"); // get the list of terminals ... std::vector<pstring> terms(nt.setup().get_terminals_for_device_name(d->name())); out += "," + f->param_desc(); for (const auto &p : plib::psplit(f->param_desc(),",") ) { if (plib::startsWith(p, "+")) { plib::container::remove(terms, p.substr(1)); } } out += ")"; pout("{}\n", out); if (terms.size() > 0) { pstring t = ""; for (auto & j : terms) t += "," + j; pout("\tTerminals: {}\n", t.substr(1)); } devs.emplace_back(std::move(d)); } }
vguard<Ontology::TermIndex> Ontology::toposortTermIndex() const { deque<TermIndex> S; vguard<TermIndex> L, nParents (terms()); int edges = 0; for (TermIndex c = 0; c < terms(); ++c) { nParents[c] = parents[c].size(); edges += nParents[c]; if (nParents[c] == 0) S.push_back (c); } while (S.size()) { const TermIndex n = S.front(); S.pop_front(); L.push_back (n); for (auto m : children[n]) { --edges; if (--nParents[m] == 0) S.push_back (m); } } if (edges > 0) throw std::domain_error ("Ontology graph is cyclic, can't toposort"); return L; }
static node *rule(prolog_obj_t *o) { node *x = new_node(o, RULE); PDEBUG(x->type, "rule"); x->o1 = term(o); if(o->sym == PERIOD) return x; if(o->sym == ASSIGN) { next_sym(o); x->o2 = terms(o); if(o->sym != PERIOD) RECOVER(o, "expected '.'"); return x; } RECOVER(o, "expected ':-' or '.'"); return x; }
Rcpp::List reTrms::condVar(double scale) { if (scale < 0 || !R_finite(scale)) throw runtime_error("scale must be non-negative and finite"); int nf = d_flist.size(); IntegerVector nc = ncols(), nl = nlevs(), nct = nctot(), off = offsets(); List ans(nf); CharacterVector nms = d_flist.names(); ans.names() = clone(nms); for (int i = 0; i < nf; i++) { int ncti = nct[i], nli = nl[i]; IntegerVector trms = terms(i); int *cset = new int[ncti], nct2 = ncti * ncti; NumericVector ansi(Dimension(ncti, ncti, nli)); ans[i] = ansi; double *ai = ansi.begin(); for (int j = 0; j < nli; j++) { int kk = 0; for (int jj = 0; jj < trms.size(); jj++) { int tjj = trms[jj]; for (int k = 0; k < nc[tjj]; k++) cset[kk++] = off[tjj] + j * nc[tjj] + k; } CHM_SP cols = M_cholmod_submatrix(&d_Lambda, (int*)NULL, -1, cset, ncti, 1/*values*/, 1/*sorted*/, &c); CHM_SP sol = d_L.spsolve(CHOLMOD_A, cols); CHM_SP tcols = M_cholmod_transpose(cols, 1/*values*/, &c); M_cholmod_free_sparse(&cols, &c); CHM_SP var = M_cholmod_ssmult(tcols, sol, 0/*stype*/, 1/*values*/, 1/*sorted*/, &c); M_cholmod_free_sparse(&sol, &c); M_cholmod_free_sparse(&tcols, &c); CHM_DN dvar = M_cholmod_sparse_to_dense(var, &c); M_cholmod_free_sparse(&var, &c); Memcpy(ai + j * nct2, (double*)dvar->x, nct2); M_cholmod_free_dense(&dvar, &c); } delete[] cset; transform(ansi.begin(), ansi.end(), ansi.begin(), bind2nd(multiplies<double>(), scale * scale)); } return ans; }
static void listdevices() { netlist_tool_t nt("netlist"); nt.init(); netlist::factory_list_t &list = nt.setup().factory(); nt.setup().register_source(std::make_shared<netlist::source_proc_t>("dummy", &netlist_dummy)); nt.setup().include("dummy"); nt.setup().start_devices(); nt.setup().resolve_inputs(); for (auto & f : list) { pstring out = plib::pfmt("{1} {2}(<id>")(f->classname(),"-20")(f->name()); pstring terms(""); auto d = f->Create(nt.setup().netlist(), "dummy"); // get the list of terminals ... for (auto & inp : d->m_terminals) { if (inp.startsWith(d->name() + ".")) inp = inp.substr(d->name().len() + 1); terms += "," + inp; } if (f->param_desc().startsWith("+")) { out += "," + f->param_desc().substr(1); terms = ""; } else if (f->param_desc() == "-") { /* no params at all */ } else { out += "," + f->param_desc(); } out += ")"; printf("%s\n", out.cstr()); if (terms != "") printf("Terminals: %s\n", terms.substr(1).cstr()); } }
void ilp_problem_t::add_constraints_of_transitive_unifications() { std::list< const hash_set<term_t>* > clusters = m_graph->enumerate_variable_clusters(); for( auto cl = clusters.begin(); cl != clusters.end(); ++cl ) { if( (*cl)->size() <= 2 ) continue; std::vector<term_t> terms( (*cl)->begin(), (*cl)->end() ); for( size_t i = 2; i < terms.size(); ++i ) for( size_t j = 1; j < i; ++j ) for( size_t k = 0; k < j; ++k ) { add_constraints_of_transitive_unification( terms[i], terms[j], terms[k]); } } }
void Ontology::init (const TermParentsMap& termParents) { auto newTerm = [&](const TermName& term) -> void { termIndex[term] = terms(); termName.push_back (term); parents.push_back (vguard<TermIndex>()); children.push_back (vguard<TermIndex>()); }; for (auto& tp : termParents) newTerm (tp.first); for (auto& tp : termParents) { const TermIndex t = termIndex[tp.first]; for (auto& pn : tp.second) { if (!termIndex.count(pn)) newTerm (pn); const TermIndex p = termIndex[pn]; parents[t].push_back (p); children[p].push_back (t); } } }
int64 problem101(int64 n) { if (n <= 0) { return 0; } vector<vector<int64>> diffs((uint32)n + 1, vector<int64>((uint32)n + 1, -1)); vector<int64> terms((uint32)n + 1); for (int64 x = 1; x <= n; x++) { int64 sum = 0; for (int64 i = 0; i <= n; i++) { if (i % 2 == 0) { sum += power(x, i); } else { sum -= power(x, i); } } diffs[0][x] = sum; } for (int64 term = 1; term < n; term++) { for (int64 x = 1; x <= n - term; x++) { diffs[term][x] = diffs[term - 1][x + 1] - diffs[term - 1][x]; } } int64 diffResult = 0; for (int64 term = 1; term <= n; term++) { int64 expectedTerm = diffs[0][term]; for (int64 i = term - 1; i >= 1; i--) { expectedTerm += diffs[term - i][i]; } diffResult += expectedTerm; } return diffResult; }
/** * Create a composite function from an expression. * @param expr :: The input expression * @param parentAttributes :: An output map filled with the attribute name & * values of the parent function * @return A pointer to the created function */ CompositeFunction_sptr FunctionFactoryImpl::createComposite( const Expression &expr, std::map<std::string, std::string> &parentAttributes) const { if (expr.name() != ";") inputError(expr.str()); if (expr.size() == 0) { return CompositeFunction_sptr(); } const std::vector<Expression> &terms = expr.terms(); auto it = terms.cbegin(); const Expression &term = it->bracketsRemoved(); CompositeFunction_sptr cfun; if (term.name() == "=") { if (term.terms()[0].name() == "composite") { cfun = boost::dynamic_pointer_cast<CompositeFunction>( createFunction(term.terms()[1].name())); if (!cfun) inputError(expr.str()); ++it; } else if (term.terms()[0].name() == "name") { cfun = boost::dynamic_pointer_cast<CompositeFunction>( createFunction("CompositeFunction")); if (!cfun) inputError(expr.str()); } else { inputError(expr.str()); } } else if (term.name() == ",") { auto firstTerm = term.terms().cbegin(); if (firstTerm->name() == "=") { if (firstTerm->terms()[0].name() == "composite") { cfun = boost::dynamic_pointer_cast<CompositeFunction>( createSimple(term, parentAttributes)); if (!cfun) inputError(expr.str()); ++it; } else if (firstTerm->terms()[0].name() == "name") { cfun = boost::dynamic_pointer_cast<CompositeFunction>( createFunction("CompositeFunction")); if (!cfun) inputError(expr.str()); } else { inputError(expr.str()); } } } else if (term.name() == ";") { cfun = boost::dynamic_pointer_cast<CompositeFunction>( createFunction("CompositeFunction")); if (!cfun) inputError(expr.str()); } else { inputError(expr.str()); } if (!cfun) inputError(expr.str()); for (; it != terms.end(); ++it) { const Expression &term = it->bracketsRemoved(); IFunction_sptr fun; std::map<std::string, std::string> pAttributes; if (term.name() == ";") { fun = createComposite(term, pAttributes); if (!fun) continue; } else { std::string parName = term[0].name(); if (parName.size() >= 10 && parName.substr(0, 10) == "constraint") { addConstraints(cfun, term[1]); continue; } else if (parName == "ties") { addTies(cfun, term[1]); continue; } else { fun = createSimple(term, pAttributes); } } cfun->addFunction(fun); size_t i = cfun->nFunctions() - 1; for (auto &pAttribute : pAttributes) { // Apply parent attributes of the child function to this function. If this // function doesn't have those attributes, they get passed up the chain to // this function's parent. if (cfun->hasLocalAttribute(pAttribute.first)) { cfun->setLocalAttributeValue(i, pAttribute.first, pAttribute.second); } else { parentAttributes[pAttribute.first] = pAttribute.second; } } } if (cfun) { cfun->applyTies(); } return cfun; }
static void listdevices() { netlist_tool_t nt("netlist"); nt.init(); netlist::factory_list_t &list = nt.setup().factory(); nt.setup().register_source(std::make_shared<netlist::source_proc_t>("dummy", &netlist_dummy)); nt.setup().include("dummy"); nt.setup().start_devices(); nt.setup().resolve_inputs(); std::vector<plib::owned_ptr<netlist::core_device_t>> devs; for (auto & f : list) { pstring out = plib::pfmt("{1} {2}(<id>")(f->classname(),"-20")(f->name()); pstring terms(""); auto d = f->Create(nt.setup().netlist(), f->name() + "_lc"); // get the list of terminals ... for (auto & t : nt.setup().m_terminals) { if (t.second->name().startsWith(d->name())) { pstring tn(t.second->name().substr(d->name().len()+1)); if (tn.find(".")<0) terms += ", " + tn; } } for (auto & t : nt.setup().m_alias) { if (t.first.startsWith(d->name())) { pstring tn(t.first.substr(d->name().len()+1)); if (tn.find(".")<0) terms += ", " + tn; } } if (f->param_desc().startsWith("+")) { out += "," + f->param_desc().substr(1); terms = ""; } else if (f->param_desc() == "-") { /* no params at all */ } else { out += "," + f->param_desc(); } out += ")"; printf("%s\n", out.cstr()); if (terms != "") printf("Terminals: %s\n", terms.substr(1).cstr()); devs.push_back(std::move(d)); } }
void BaseInputRewriter::translateChoice(Rule*& rule,vector<Rule*>& ruleRewrited) { unsigned id=IdGenerator::getInstance()->getId(); unsigned counter=1; // Create an auxiliary rule in order to ground the body only once. // First the variables shared between the atoms in the body // and the choice atom are found, these variables will be // the term of the auxiliary atom in the head of the auxiliary rule Atom* choice =rule->getAtomInHead(0); Atom *auxiliaryAtomBody=nullptr; if(rule->getSizeBody()>1){ set_term variables_in_choice=choice->getVariable(); set_term variables_in_body; for(unsigned i=0;i<rule->getSizeBody();++i){ auto atom=rule->getAtomInBody(i); if(atom->isNegative())continue; set_term variables; if(atom->isAggregateAtom()) variables=atom->getGuardVariable(); else variables=atom->getVariable(); variables_in_body.insert(variables.begin(),variables.end()); } set_term variables_intersection; Utils::intersectionSet(variables_in_choice,variables_in_body,variables_intersection); Rule * body_rule=new Rule; if(rule->isMustBeRewritedForAggregates()) body_rule->setMustBeRewritedForAggregates(true); //Body body_rule->setBody(rule->getBody()); //Head string predicate_name=AUXILIARY+SEPARATOR+to_string(id)+SEPARATOR+to_string(counter); vector<Term*> terms(variables_intersection.begin(),variables_intersection.end()); auxiliaryAtomBody=generateNewAuxiliaryAtom(predicate_name,terms); body_rule->addInHead(auxiliaryAtomBody); ruleRewrited.push_back(body_rule); counter++; }else{ if(rule->getSizeBody()==1) auxiliaryAtomBody=rule->getAtomInBody(0); } // For each choice element a new disjunctive auxiliary rule is created. // Each rule has in the head a disjunction with a the first atom of the choice element and a new auxiliary atom // having the same terms of the first atom, while in the body it contains the remaining atoms of the choice element // and the auxiliary atom previously created for the body. // Also, the aggregate elements for the constraint rule are created (see below) vector<AggregateElement*> elements = rewriteChoiceElements(id, counter,choice, auxiliaryAtomBody, ruleRewrited); // Finally a constraint rule is created. // It has as body the auxiliary atom previously created for the body, and a negated count aggregate // whose guard are the same of the choice atom and inside contains the first atom of each choice element // and as aggregate terms all its terms rewriteChoiceConstraint(elements, auxiliaryAtomBody, choice, ruleRewrited); if(rule->getSizeBody()==1) delete auxiliaryAtomBody; rule->deleteBody([](Atom* atom){ return 0; }); rule->deleteHead([](Atom* atom){ return 1; }); delete rule; rule=0; }