void
PredicatesAtom::retrieve(const Query& query, Answer& answer) throw (PluginError)
{
RegistryPtr reg = query.interpretation->getRegistry();
// Retrieve answer index and answer-set index
int answerindex = query.input[0].address;
int answersetindex = query.input[1].address;
// check index validity
if (answerindex < 0 || answerindex >= resultsetCache.size()){
throw PluginError("An invalid answer handle was passed to atom &predicates");
}else if(answersetindex < 0 || answersetindex >= resultsetCache[answerindex].size()){
throw PluginError("An invalid answer-set handle was passed to atom &predicates");
}else{
// Go through all atoms of the given answer_set
for(Interpretation::Storage::enumerator it =
(resultsetCache[answerindex])[answersetindex]->getStorage().first();
it != (resultsetCache[answerindex])[answersetindex]->getStorage().end(); ++it){
if (!reg->ogatoms.getIDByAddress(*it).isAuxiliary()){
ID ogid(ID::MAINKIND_ATOM | ID::SUBKIND_ATOM_ORDINARYG, *it);
const OrdinaryAtom& ogatom = reg->ogatoms.getByID(ogid);
Tuple t;
t.push_back(ogatom.tuple[0]);
t.push_back(ID::termFromInteger(ogatom.tuple.size() - 1));
answer.get().push_back(t);
}
}
}
}
Tuple Database::joinTuple(set<pair<int, int>> pairs, Tuple t1, Tuple t2){
Tuple newTuple;
for (int i = 0; i<t1.size(); i++){
newTuple.push_back(t1[i]);
}
for (auto i : t2){
newTuple.push_back(i);
}
return newTuple;
}
Tuple Relation::do_product(Tuple t1, Tuple t2) {
Tuple t = Tuple();
for (auto item : t1) {
t.push_back(item);
}
for (auto item2 : t2) {
t.push_back(item2);
}
return t;
}
void Join::execProject(const Tuple &left_tuple,
const Tuple &right_tuple,
Tuple &output_tuple) const
{
output_tuple.clear();
for (ColID i = 0; i < numOutputCols(); ++i) {
if (selected_input_col_ids_[i] < left_child_->numOutputCols()) {
output_tuple.push_back(left_tuple[selected_input_col_ids_[i]]);
} else {
output_tuple.push_back(right_tuple[selected_input_col_ids_[i]
- left_child_->numOutputCols()]);
}
}
}
Tuple Interpretter::predToTuple(Predicate query) {
Tuple out;
for (auto item : query.getParams()) {
out.push_back(item.toString());
}
return out;
}
void
TestRacerNRQL::runRacerRetrieveTest()
{
std::stringstream sst;
Tuple tup;
tup.push_back(Term("X"));
tup.push_back(Term("Y"));
AtomSet as;
AtomPtr ap1(new Atom("foo(X)"));
AtomPtr ap2(new Atom("moo(X,Y)"));
as.insert(ap1);
as.insert(ap2);
KBManager kb("DEFAULT");
DLQuery::shared_pointer dlq(new DLQuery(Ontology::createOntology(test),as,tup));
Query q(kb,dlq,Term(""),Term(""),Term(""),Term(""),AtomSet());
NRQLRetrieve<NRQLConjunctionBuilder> nrql(q);
sst << nrql;
std::string s = sst.str();
std::cout << s << std::endl;
CPPUNIT_ASSERT(s == "(retrieve ($?X $?Y) (and ($?X $?Y |http://www.test.com/test#moo|) ($?X |http://www.test.com/test#foo|)) :abox DEFAULT)");
}
void SimpleFilter::precalculate(int order, int mask)
{
if (mask & (H2D_FN_DX | H2D_FN_DY | H2D_FN_DXX | H2D_FN_DYY | H2D_FN_DXY))
error("Filter not defined for derivatives.");
Quad2D* quad = quads[cur_quad];
int np = quad->get_num_points(order);
Node* node = new_node(H2D_FN_VAL, np);
// precalculate all solutions
for (int i = 0; i < num; i++)
sln[i]->set_quad_order(order, item[i]);
for (int j = 0; j < num_components; j++)
{
// obtain corresponding tables
scalar* tab[10];
for (int i = 0; i < num; i++)
{
int a = 0, b = 0, mask = item[i];
if (mask >= 0x40) { a = 1; mask >>= 6; }
while (!(mask & 1)) { mask >>= 1; b++; }
tab[i] = sln[i]->get_values(num_components == 1 ? a : j, b);
if (tab[i] == NULL) error("Value of 'item%d' is incorrect in filter definition.", i+1);
}
Tuple<scalar*> values;
for(int i = 0; i < this->num; i++)
values.push_back(tab[i]);
// apply the filter
filter_fn(np, values, node->values[j][0]);
}
Relation Relation::project(vector<int>& index1)
{
Relation temp;
Tuple tempTuplele;
for(int i=0; i<index1.size(); i++)
{
temp.my_values.ADD(my_values.scheme_string(index1[i]));
}
for (set<Tuple>::iterator it = Tuple_Set.begin(); it != Tuple_Set.end(); ++it)
{
for(int i = 0; i < index1.size(); i++)
{
tempTuplele.push_back((*it)[index1[i]]);
}
temp.Tuple_Set.insert(tempTuplele);
tempTuplele.clear();
}
temp.my_name = my_name;
return temp;
}
void
CallHexFileAtom::retrieve(const Query& query, Answer& answer) throw (PluginError)
{
RegistryPtr reg = query.interpretation->getRegistry();
std::string programpath;
std::string cmdargs;
InterpretationConstPtr inputfacts = query.interpretation;
try{
const Tuple& params = query.input;
// load program
programpath = reg->terms.getByID(params[0]).getUnquotedString();
// Retrieve command line arguments
if (params.size() > 1 + arity){
cmdargs = reg->terms.getByID(params[1 + arity]).getUnquotedString();
}
// Build hex call identifier
HexCall hc(HexCall::HexFile, programpath, cmdargs, inputfacts);
// request entry from cache (this will automatically add it if it's not contained yet)
Tuple out;
out.push_back(ID::termFromInteger(resultsetCache[hc]));
answer.get().push_back(out);
}catch(PluginError){
throw;
}catch(...){
std::stringstream msg;
msg << "Nested Hex program \"" << programpath << "\" failed. Command line arguments were: " << cmdargs;
throw PluginError(msg.str());
}
}
void Interpretter::evalRules(vector <Rule>& rulelist) {
for (Rule rule : rulelist) {
cout << rule.toString();
output += rule.toString();
//get the first rule, then iterate thru the rest, adding to the new "joined" Relation
Relation joined = db[rule.getPredicates()[0].getID()];
// set a joined scheme, based on predicate[0]'s params. And give it to me in tuple format
joined.redoScheme(rule.getPredicates()[0].getParams());
if (rulelist.size() > 1) {
vector <Relation> processedPreds;
if (rule.getPredicates().size() > 1) {
//for each Predicate (after the first) in the rule
for (int i = 1; i < rule.getPredicates().size(); i++) {
Relation r = db[rule.getPredicates()[i].getID()];
Tuple predT = predToTuple(rule.getPredicates()[i]);
Relation selected = r.select(predT);
//output += selected.toString();
//Relation projected = selected.project(predT);
//output += projected.toString();
Relation renamed = selected.rename(predT);
processedPreds.push_back(renamed);
joined = joined.join(renamed);
}
}
}
Tuple renameScheme;
//cout << "rule.getName() = " << rule.getName() << endl;
for (auto item : rule.getParams()) {
renameScheme.push_back(item.getVal());
}
//cout << "joined" << joined.toString();
Relation projectRule = joined.project2(renameScheme); //project with the original columns
//Relation renameRule = projectRule.rename(renameScheme); // use the original scheme
//cout << renameRule.toString();
int prevSize = db[rule.getName()].getRelSize();
for (auto tuple : projectRule.getTuples()) {
db[rule.getName()].add(tuple);
//if it actually added
if (db[rule.getName()].getRelSize() > prevSize) {
output += db[rule.getName()].tupleToString(tuple);
prevSize = db[rule.getName()].getRelSize();
addedTuples++;
}
}
}
}
packToken lazy_class_exec(packMap scope) {
packMap _this = scope->find("this")->asMap();
Function* func = (*_this)["func"].asFunc();
packList args = (*_this)["args"].asList();
Tuple tuple;
// Copy the tokens from this.args:
for (packToken item : args->list) {
tuple.push_back(item);
}
// Copy the tokens received as exec() arguments:
args = scope->find("arglist")->asList();
for (packToken item : args->list) {
tuple.push_back(item);
}
return Function::call(_this, func, &tuple, packMap(scope->parent));
}
void Database::initFacts(vector<Predicate> facts){
for(int i = 0; i < (int)facts.size(); i++){
Predicate r = facts[i];
string name = r.getID();
Tuple t;
for(int j = 0; j < (int)r.getParameters().size(); j++)
t.push_back(r.getParameters()[j].getValue());
addTuple(name, t);
}
}
virtual void retrieve(const Query& q, Answer& a) throw (dlvhex::PluginError)
{
// get inputs
assert(q.input.size() == 3);
ID preddisarm = q.input[0];
ID predlook = q.input[1];
ID time = q.input[2];
LOG(INFO,"calculating senseNotArmed2 extatom for " << preddisarm << "/" << predlook << "/" << time);
// get outputs
assert(q.pattern.size() == 0);
// check if <preddisarm>(time) and <predlook>(time) part of interpretation
Tuple tdisarm;
tdisarm.push_back(preddisarm);
tdisarm.push_back(time);
ID iddisarm = registry->ogatoms.getIDByTuple(tdisarm);
Tuple tlook;
tlook.push_back(predlook);
tlook.push_back(time);
ID idlook = registry->ogatoms.getIDByTuple(tlook);
if( iddisarm == ID_FAIL || idlook == ID_FAIL )
{
// cannot be part of interpretation -> return no tuple as condition not true
return;
}
// check interpretation
assert(q.interpretation != 0);
if( q.interpretation->getFact(iddisarm.address) &&
q.interpretation->getFact(idlook.address) )
{
// found both facts
Tuple t;
a.get().push_back(t);
}
}
Tuple Relation::join_tuples(Tuple t1, Tuple t2, std::vector<std::pair<int, int>> common_attributes) {
Tuple t = Tuple();
for (auto item : t1) {
t.push_back(item);
}
int num_attributes = t2.size();
for (int i = 0; i < num_attributes; i++) {
// Make sure you aren't adding common attributes twice
bool is_common_attribute = false;
for (auto pair : common_attributes) {
if (i == pair.second)
is_common_attribute = true;
}
if (!is_common_attribute) {
t.push_back(t2.at(i));
}
}
return t;
}
Relation Relation::project(vector<int> &indexList){
Relation r = Relation(name);
for(int i = 0; i < (int)indexList.size(); i++)
r.schema.attributes.push_back(schema.attributes[indexList[i]]);
if(indexList.size() != 0){
set<Tuple>::iterator it;
for(it = tuples.begin(); it != tuples.end(); it++){
Tuple newTuple = Tuple();
for(int j = 0; j < (int)indexList.size(); j++)
newTuple.push_back((*it)[indexList[j]]);
r.tuples.insert(newTuple);
}
}
return r;
}
Relation Relation::project(std::vector<int> indices) {
Relation temp = Relation(this->name);
int num_indices = indices.size();
for (int i = 0; i < num_indices; i++) {
temp.scheme.push_back(this->scheme.at(indices.at(i)));
}
for (Tuple tuple : this->tuples) {
Tuple t;
for (int i = 0; i < num_indices; i++) {
t.push_back(tuple.at(indices.at(i)));
}
temp.tuples.insert(t);
}
return temp;
}
void Paving::save(const std::string filename, const Names &titles, const Names &names) const {
if (empty()) return;
Tuple vs;
for (nat v = 0; v < names.size(); ++v) {
nat n = varbox_.var(names[v]);
if (n < nvars())
vs.push_back(n);
}
std::ostringstream os;
os << filename;
for (nat i = 0; i < vs.size(); ++i)
os << "_" << varbox_.name(vs[i]);
os << ".dat";
if (vs.empty()) {
vs.resize(varbox_.size());
for (nat v = 0; v < varbox_.size(); ++v)
vs[v] = v;
}
std::ofstream f;
f.open(os.str().c_str(), std::ofstream::out);
f << "## File: " << os.str() << std::endl;
f << "## Type: " << type_ << std::endl;
f << "## Vars:" << std::endl;
nat width = 2 * Kodiak::precision();
for (nat i = 0; i < vs.size(); ++i)
f << std::setw(width) << varbox_.name(vs[i]);
f << std::endl;
for (nat i = 0; i < vs.size(); ++i)
f << std::setw(width) << varbox_.box()[vs[i]].inf();
f << std::endl;
for (nat i = 0; i < vs.size(); ++i)
f << std::setw(width) << varbox_.box()[vs[i]].sup();
f << std::endl;
f << std::endl;
for (nat i = 0; i < titles.size(); ++i) {
f << "## " << titles[i] << ": " << size(i) << " boxes " << std::endl;
if (i < boxes_.size() && boxes_[i].size() > 0)
save_boxes(f, boxes_[i], vs, width);
else
f << std::endl;
}
f.close();
std::cout << "Kodiak (save): Boxes were saved in file " << os.str() << std::endl;
}
virtual void retrieve(const Query& q, Answer& a) throw (dlvhex::PluginError)
{
#if 0
// get inputs
assert(q.input.size() == 2);
ID pred = q.input[0];
ID cmp = q.input[1];
LOG(INFO,"calculating above extatom for predicate " << pred << " and symbol " << cmp);
const Term& cmpt = registry->terms.getByID(cmp);
// get query
assert(q.pattern.size() == 1);
ID out = q.pattern.front();
// build set of found targets
assert(q.interpretation != 0);
dlvhex::OrdinaryAtomTable::PredicateIterator it, it_end;
assert(registry != 0);
for(boost::tie(it, it_end) = registry->ogatoms.getRangeByPredicateID(pred);
it != it_end; ++it)
{
const dlvhex::OrdinaryAtom& oatom = *it;
// skip ogatoms not present in interpretation
if( !q.interpretation->getFact(registry->ogatoms.getIDByStorage(oatom).address) )
continue;
// the edge predicate must be unary
assert(oatom.tuple.size() == 2);
const Term& t = registry->terms.getByID(oatom.tuple[1]);
if( t.symbol >= cmpt.symbol )
{
if( (out.isTerm() && out.isVariableTerm()) ||
(out == oatom.tuple[1]) )
{
Tuple t;
t.push_back(oatom.tuple[1]);
a.get().push_back(t);
}
}
}
#endif
throw std::runtime_error("todo implement SenseNotArmed1PluginAtom::retrieve");
}
ConstraintTree::ConstraintTree (vector<vector<string>> names)
{
assert (names.empty() == false);
assert (names.front().empty() == false);
unsigned nrLvs = names[0].size();
for (size_t i = 0; i < nrLvs; i++) {
logVars_.push_back (LogVar (i));
}
root_ = new CTNode (0, 0);
logVarSet_ = LogVarSet (logVars_);
for (size_t i = 0; i < names.size(); i++) {
Tuple t;
for (size_t j = 0; j < names[i].size(); j++) {
assert (names[i].size() == nrLvs);
t.push_back (LiftedUtils::getSymbol (names[i][j]));
}
addTuple (t);
}
}
void
AnswerSetsAtom::retrieve(const Query& query, Answer& answer) throw (PluginError)
{
// Retrieve answer index
int answerindex = query.input[0].address;
// check index validity
if (answerindex < 0 || answerindex >= resultsetCache.size()){
throw PluginError("An invalid answer handle was passed to atom &answersets");
}else{
// Return handles to all answer-sets of the given answer (all integers from 0 to the number of answer-sets minus 1)
int i = 0;
for (HexAnswer::iterator it = resultsetCache[answerindex].begin(); it != resultsetCache[answerindex].end(); it++){
Tuple out;
out.push_back(ID::termFromInteger(i++));
answer.get().push_back(out);
}
}
}
void
ArgumentsAtom::retrieve(const Query& query, Answer& answer) throw (PluginError)
{
RegistryPtr reg = query.interpretation->getRegistry();
// Extract answer index, answerset index and predicate to retrieve
int answerindex = query.input[0].address;
int answersetindex = query.input[1].address;
ID predicate = query.input[2];
// check index validity
if (answerindex < 0 || answerindex >= resultsetCache.size()){
throw PluginError("An invalid answer handle was passed to atom &arguments");
}else if(answersetindex < 0 || answersetindex >= resultsetCache[answerindex].size()){
throw PluginError("An invalid answer-set handle was passed to atom &arguments");
}else{
int runningindex = 0;
// Go through all atoms of the given answer_set
for(Interpretation::Storage::enumerator it =
(resultsetCache[answerindex])[answersetindex]->getStorage().first();
it != (resultsetCache[answerindex])[answersetindex]->getStorage().end(); ++it){
ID ogid(ID::MAINKIND_ATOM | ID::SUBKIND_ATOM_ORDINARYG, *it);
const OrdinaryAtom& ogatom = reg->ogatoms.getByID(ogid);
// If the atom is built upon the given predicate, return it's parameters
if (ogatom.tuple[0] == predicate){
// special case of index "s": positive or strongly negated
Tuple ts;
ts.push_back(ID::termFromInteger(runningindex));
Term t(ID::MAINKIND_TERM | ID::SUBKIND_TERM_CONSTANT, "s");
ts.push_back(reg->storeTerm(t));
ts.push_back(ID::termFromInteger(/*it->isStronglyNegated() ? 1 :*/ 0)); // TODO: check if the atom is strongly negated
answer.get().push_back(ts);
// Go through all parameters
for (int i = 1; i < ogatom.tuple.size(); ++i){
Tuple t;
t.push_back(ID::termFromInteger(runningindex));
t.push_back(ID::termFromInteger(i - 1));
t.push_back(ogatom.tuple[i]);
answer.get().push_back(t);
}
runningindex++;
}
}
}
}
void
TestRacerNRQL::runRacerPremiseRetrieveTest()
{
std::stringstream sst;
Tuple tup;
tup.push_back(Term("X"));
tup.push_back(Term("Y"));
AtomSet as;
AtomPtr ap1(new Atom("foo(X)"));
AtomPtr ap2(new Atom("moo(X,Y)"));
as.insert(ap1);
as.insert(ap2);
AtomSet ints;
AtomPtr ap4(new Atom("pc(foo,a)"));
AtomPtr ap5(new Atom("pr(moo,a,b)"));
ints.insert(ap4);
ints.insert(ap5);
KBManager kb("DEFAULT");
DLQuery::shared_pointer dlq(new DLQuery(Ontology::createOntology(test),as,tup));
Query q(kb,dlq,Term("pc"),Term(""),Term("pr"),Term(""),ints);
NRQLRetrieveUnderPremise<NRQLConjunctionBuilder> nrql(q);
sst << nrql;
std::string s = sst.str();
std::cout << s << std::endl;
URI u(testuri, true); // absolute pathname
CPPUNIT_ASSERT(s == "(retrieve-under-premise ((related |http://www.test.com/test#a| |http://www.test.com/test#b| |http://www.test.com/test#moo|) (instance |http://www.test.com/test#a| |http://www.test.com/test#foo|)) ($?X $?Y) (and ($?X $?Y |http://www.test.com/test#moo|) ($?X |http://www.test.com/test#foo|)) :abox |" + u.getString() + "|)");
}
TupleSet
ConstraintTree::tupleSet (const LogVars& originalLvs)
{
LogVars uniqueLvs;
for (size_t i = 0; i < originalLvs.size(); i++) {
if (Util::contains (uniqueLvs, originalLvs[i]) == false) {
uniqueLvs.push_back (originalLvs[i]);
}
}
Tuples tuples;
moveToTop (uniqueLvs);
unsigned stopLevel = uniqueLvs.size();
getTuples (root_, Tuples(), stopLevel, tuples, CTNodes() = {});
if (originalLvs.size() != uniqueLvs.size()) {
vector<size_t> indexes;
indexes.reserve (originalLvs.size());
for (size_t i = 0; i < originalLvs.size(); i++) {
indexes.push_back (Util::indexOf (uniqueLvs, originalLvs[i]));
}
Tuples tuples2;
tuples2.reserve (tuples.size());
for (size_t i = 0; i < tuples.size(); i++) {
Tuple t;
t.reserve (originalLvs.size());
for (size_t j = 0; j < originalLvs.size(); j++) {
t.push_back (tuples[i][indexes[j]]);
}
tuples2.push_back (t);
}
return TupleSet (tuples2);
}
return TupleSet (tuples);
}
void
UniqueLinSolveAtom::retrieve(const Query& query,
Answer& answer) throw (PluginError)
{
Tuple parms = query.getInputTuple();
std::string matrixPred = "";
std::string constantPred = "";
int argc = 2;
char* argv[] = {"-linkname", "math -mathlink"};
//check number and type of arguments
if (parms.size()!= 2)
{
throw PluginError("Wrong number of arguments");
}
else
{
if(parms[0].isSymbol() && parms[1].isSymbol())
{
matrixPred = parms[0].getString();
//std::cout << "Matrixpraedikat: " << matrixPred << std::endl;
constantPred = parms[1].getString();
//std::cout << "Vektorpraedikat: " << vectorPred << std::endl;
}
else
{
throw PluginError("Wrong type of arguments");
}
}
//get complete Interpretation of given predicates in query
AtomSet totalInt = query.getInterpretation();
AtomSet matrixInt;
AtomSet constantInt;
if (totalInt.empty())
{
throw PluginError("Could not find any interpretion");
}
else
{
// separate interpretation into facts of first predicate (matrix)
totalInt.matchPredicate(matrixPred, matrixInt);
// and into facts of second predicate (vector)
totalInt.matchPredicate(constantPred, constantInt);
}
int mRows = 0;
int mColumns = 0;
int cRows = 0;
int cColumns = 0;
evaluateMatrix(matrixInt, mRows, mColumns);
evaluateVector(constantInt, cRows, cColumns);
if(mRows != cRows) throw PluginError("Coefficient matrix and target vector(s) or matrix do not have the same dimensions.");
std::vector <std::vector <std::string> > matrix(mRows);
for(int i = 0; i < mRows; i++)
matrix[i].resize(mColumns);
std::vector <std::vector <std::string> > constants(cRows);
for (int i = 0; i < cRows; i++)
constants[i].resize(cColumns);
//write the values of the Atoms in the Interpretation into std::vectors for further processing
convertMatrixToVector(matrixInt, mRows, mColumns, matrix);
convertMatrixToVector(constantInt, cRows, cColumns, constants);
//check if matrix and target vector or matrix are fully defined
checkVector(matrix, mRows, mColumns, matrixPred);
checkVector(constants, cRows, cColumns, constantPred);
//convert matrix to MatrixRank-expression and calculate rank of coefficient matrix A
std::string coeffMRankExpr = toMatrixRankExpr(matrix, mRows, mColumns);
//std::cout << "MatrixRank expression: " << coeffMRankExpr << std::endl;
int coeffMRank = calculateRank(argc, argv, coeffMRankExpr);
//convert matrix A and target b to MatrixRank-expression and calculate rank
//of extended coefficient matrix [A,b]
std::string extendedMRankExpr = toMatrixRankExpr(matrix, mRows, mColumns, constants, cRows, cColumns);
//std::cout << "Extended MatrixRank expression: " << extendedMRankExpr << std::endl;
int extCoeffMRank = calculateRank(argc, argv, extendedMRankExpr);
//compare calculated ranks and number of matrix colums, iff they are equal,
//a unique solution for the matrix equation exists
if ((coeffMRank == extCoeffMRank) && (coeffMRank == mColumns))
{
std::string linSolExpr = toLinearSolveExpr(matrix, mRows, mColumns, constants, cRows, cColumns);
std::vector <std::string> result;
result = calculateSolution(argc, argv, linSolExpr);
if(result.size() != mColumns*cColumns)
throw PluginError("Wrong number of arguments in result vector");
Tuple out;
int index = 0;
//fill the result values with correct indices into Tuple out
//and add all Tuples to Answer
for (int r = 1; r <= mColumns; r++)
{
for(int c = 1; c<= cColumns; c++)
{
out.push_back(Term(r));
out.push_back(Term(c));
out.push_back(Term(result[index],true));
answer.addTuple(out);
out.clear();
index++;
}
}
}
}
int main(int argc, char* argv[]) {
std::string file_name;
if (argc < 2) {
std::cerr << "please specify the file name" << std::endl;
return 1;
}
file_name = argv[1];
std::ifstream infile;
#ifdef _MSC_VER
// handling file names with non-ascii characters
wchar_t *wcstring = new wchar_t[file_name.size()+1];
setlocale(LC_ALL, ".OCP");
mbstowcs(wcstring, file_name.c_str(), file_name.size()+1);
infile.open(wcstring);
delete[] wcstring;
setlocale(LC_ALL, "");
#else // _MSC_VER
infile.open(file_name.c_str());
#endif // _MSC_VER
if (!infile.is_open()) {
std::cerr << "cannot open the input file" << std::endl;
return 1;
}
SUTModel sut_model;
Assembler assembler;
try {
ct::lexer lexer(&infile);
assembler.setErrLogger(boost::shared_ptr<ErrLogger>(new ErrLogger_Cerr()));
yy::ct_parser parser(lexer,
sut_model.param_specs_,
sut_model.strengths_,
sut_model.seeds_,
sut_model.constraints_,
assembler);
parser.parse();
} catch (std::runtime_error e) {
std::cerr << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception when parsing input file" << std::endl;
std::cerr << "exiting" << std::endl;
return 1;
}
if (assembler.numErrs() > 0) {
std::cerr << assembler.numErrs() << " errors in the input file, exiting" << std::endl;
return 2;
}
std::cout << "successfully parsed the input file" << std::endl;
std::cout << "# parameters: " << sut_model.param_specs_.size() << std::endl;
std::cout << "# strengths: " << sut_model.strengths_.size() << std::endl;
std::cout << "# seeds: " << sut_model.seeds_.size() << std::endl;
std::cout << "# constraints: " << sut_model.constraints_.size() << std::endl;
std::vector<RawStrength> raw_strengths;
TuplePool tuple_pool;
for (std::size_t i = 0; i < sut_model.strengths_.size(); ++i) {
attach_2_raw_strength(sut_model.strengths_[i], raw_strengths);
}
for (std::size_t i = 0; i < raw_strengths.size(); ++i) {
Tuple tuple;
for (std::size_t j = 0; j < raw_strengths[i].size(); ++j) {
tuple.push_back(PVPair(raw_strengths[i][j], 0));
}
if (tuple.size() <= 0) {
continue;
}
do {
tuple_pool.insert(tuple);
} while (tuple.to_the_next_tuple(sut_model.param_specs_));
}
std::cout << "# target combinations: " << tuple_pool.size() << std::endl;
TuplePool forbidden_tuple_pool;
for (std::size_t i = 0; i < sut_model.constraints_.size(); ++i) {
std::set<std::size_t> rel_pids;
sut_model.constraints_[i]->touch_pids(sut_model.param_specs_, rel_pids);
Tuple tuple;
for (std::set<std::size_t>::const_iterator iter = rel_pids.begin(); iter != rel_pids.end(); iter++) {
tuple.push_back(PVPair(*iter, 0));
}
do {
EvalType_Bool result = sut_model.constraints_[i]->Evaluate(sut_model.param_specs_, tuple);
if (!result.is_valid_ || !result.value_) {
forbidden_tuple_pool.insert(tuple);
}
} while (tuple.to_the_next_tuple_with_ivld(sut_model.param_specs_));
}
std::cout << "# forbidden combinations: " << forbidden_tuple_pool.size() << std::endl;
return 0;
}
void SimulatorAtom::retrieve(const Query& query, Answer& answer) throw (PluginError){
RegistryPtr reg = query.interpretation->getRegistry();
const Tuple& params = query.input;
// get ASP filename
std::string programpath = reg->terms.getByID(params[0]).getUnquotedString();
// if we access this file for the first time, parse the content
if (programs.find(programpath) == programs.end()){
DBGLOG(DBG, "Parsing simulation program");
InputProviderPtr ip(new InputProvider());
ip->addFileInput(programpath);
Logger::Levels l = Logger::Instance().getPrintLevels(); // workaround: verbose causes the parse call below to fail (registry pointer is 0)
Logger::Instance().setPrintLevels(0);
programs[programpath].changeRegistry(reg);
ModuleHexParser hp;
hp.parse(ip, programs[programpath]);
Logger::Instance().setPrintLevels(l);
}
ProgramCtx& pc = programs[programpath];
// construct edb
DBGLOG(DBG, "Constructing EDB");
InterpretationPtr edb = InterpretationPtr(new Interpretation(*pc.edb));
// go through all input atoms
DBGLOG(DBG, "Rewriting input");
for(Interpretation::Storage::enumerator it =
query.interpretation->getStorage().first();
it != query.interpretation->getStorage().end(); ++it){
ID ogid(ID::MAINKIND_ATOM | ID::SUBKIND_ATOM_ORDINARYG, *it);
const OrdinaryAtom& ogatom = reg->ogatoms.getByID(ogid);
// check if the predicate matches any of the input parameters to simulator atom
bool found = false;
for (int inp = 1; inp < params.size(); ++inp){
if (ogatom.tuple[0] == params[inp]){
// replace the predicate by "in[inp]"
std::stringstream inPredStr;
inPredStr << "in" << inp;
Term inPredTerm(ID::MAINKIND_TERM | ID::SUBKIND_TERM_CONSTANT, inPredStr.str());
ID inPredID = reg->storeTerm(inPredTerm);
OrdinaryAtom oareplace = ogatom;
oareplace.tuple[0] = inPredID;
// get ID of replaced atom
ID oareplaceID = reg->storeOrdinaryGAtom(oareplace);
// set this atom in the input interpretation
edb->getStorage().set_bit(oareplaceID.address);
found = true;
break;
}
}
assert(found);
}
DBGLOG(DBG, "Grounding simulation program");
OrdinaryASPProgram program(pc.registry(), pc.idb, edb);
InternalGrounderPtr ig = InternalGrounderPtr(new InternalGrounder(pc, program));
OrdinaryASPProgram gprogram = ig->getGroundProgram();
DBGLOG(DBG, "Evaluating simulation program");
GenuineSolverPtr igas = GenuineSolver::getInstance(pc, gprogram);
InterpretationPtr as = igas->getNextModel();
if (as != InterpretationPtr()){
// extract parameters from all atoms over predicate "out"
DBGLOG(DBG, "Rewrting output");
Term outPredTerm(ID::MAINKIND_TERM | ID::SUBKIND_TERM_CONSTANT, "out");
ID outPredID = reg->storeTerm(outPredTerm);
for(Interpretation::Storage::enumerator it =
as->getStorage().first();
it != as->getStorage().end(); ++it){
ID ogid(ID::MAINKIND_ATOM | ID::SUBKIND_ATOM_ORDINARYG, *it);
const OrdinaryAtom& ogatom = reg->ogatoms.getByID(ogid);
if (ogatom.tuple[0] == outPredID){
Tuple t;
for (int ot = 1; ot < ogatom.tuple.size(); ++ot){
t.push_back(ogatom.tuple[ot]);
}
answer.get().push_back(t);
}
}
}
}
