const McEnvironment* McObject::getEnvironment() const {
/* Check if the environment is set into the object */
if(!environment)
throw(GeneralError("Object " + getObjectName() + " from module " + getModuleName() +
" attempted to access the environment but there isn't a reference to it "));
return environment;
}
GenuineGroundSolverPtr GenuineGroundSolver::getInstance(ProgramCtx& ctx, const OrdinaryASPProgram& p, InterpretationConstPtr frozen, bool minCheck)
{
//DLVHEX_BENCHMARK_REGISTER_AND_SCOPE(sid, "grounding (GenuineGroundS.::getInst)");
switch (ctx.config.getOption("GenuineSolver")) {
case 1:
case 2: // internal grounder or Gringo + internal solver
{
DBGLOG(DBG, "Instantiating genuine solver with internal solver (min-check: " << minCheck << ")");
GenuineGroundSolverPtr ptr(minCheck ? new InternalGroundDASPSolver(ctx, AnnotatedGroundProgram(ctx, p), frozen) : new InternalGroundASPSolver(ctx, AnnotatedGroundProgram(ctx, p), frozen));
return ptr;
}
break;
case 3:
case 4: // internal grounder or Gringo + clasp
#ifdef HAVE_LIBCLASP
{
DBGLOG(DBG, "Instantiating genuine solver with clasp (min-check: " << minCheck << ")");
// clasp 3 is always disjunctive
GenuineGroundSolverPtr ptr(new ClaspSolver(ctx, AnnotatedGroundProgram(ctx, p), frozen));
return ptr;
}
#else
throw GeneralError("No support for clasp compiled into this binary");
#endif // HAVE_LIBCLASP
break;
default:
assert(false);
return GenuineGroundSolverPtr();
}
}
DLVHEX_NAMESPACE_BEGIN
SATSolverPtr SATSolver::getInstance(ProgramCtx& ctx, NogoodSet& ns, InterpretationConstPtr frozen)
{
switch (ctx.config.getOption("GenuineSolver")) {
case 3: case 4: // internal grounder or Gringo + clasp
#ifdef HAVE_LIBCLASP
{
DBGLOG(DBG, "Instantiating genuine sat solver with clasp");
SATSolverPtr ptr = SATSolverPtr(new ClaspSolver(ctx, ns, frozen));
return ptr;
}
#else
throw GeneralError("No support for clasp compiled into this binary");
#endif // HAVE_LIBCLINGO
break;
case 1: case 2: // internal grounder or Gringo + internal solver
default: // translation solver
{
DBGLOG(DBG, "Instantiating genuine sat solver with internal solver");
// this solver does not implement optimizations, thus all variables are always frozen
SATSolverPtr ptr = SATSolverPtr(new CDNLSolver(ctx, ns));
return ptr;
}
break;
}
}
DLVHEX_NAMESPACE_BEGIN
GenuineGrounderPtr GenuineGrounder::getInstance(ProgramCtx& ctx, const OrdinaryASPProgram& p, InterpretationConstPtr frozen)
{
switch(ctx.config.getOption("GenuineSolver")) {
case 1:
case 3: // internal grounder + internal solver or clasp
{
if (!!frozen) {
throw GeneralError("Internal grounder does not support frozen atoms");
}
DBGLOG(DBG, "Instantiating genuine grounder with internal grounder");
GenuineGrounderPtr ptr(new InternalGrounder(ctx, p));
return ptr;
}
break;
case 2:
case 4: // Gringo + internal solver or clasp
#ifdef HAVE_LIBGRINGO
{
DBGLOG(DBG, "Instantiating genuine grounder with gringo");
#ifndef GRINGO3 // GRINGO4
GenuineGrounderPtr ptr(new GringoGrounder(ctx, p, frozen));
#else // GRINGO3
// if (!!frozen){
// throw GeneralError("Gringo 3 does not support frozen atoms");
// }
GenuineGrounderPtr ptr(new GringoGrounder(ctx, p, frozen));
#endif
return ptr;
}
#else
throw GeneralError("No support for gringo compiled into this binary");
#endif // HAVE_LIBGRINGO
break;
default:
assert(false);
return GenuineGrounderPtr();
}
}
void DetailList::GetMaterials()
{
Bool success = TRUE;
fnMats = 0;
Material m;
AddMaterial( m );
for( int di = 0; di < fnDetails; di++ )
success = success && faDetails[di].GetMaterials( this );
if( !success )
throw GeneralError( "Unable to continue!" );
}
void InputProvider::addFileInput(const std::string& filename)
{
std::ifstream ifs;
ifs.open(filename.c_str());
if (!ifs.is_open()) {
throw GeneralError("File " + filename + " not found");
}
pimpl->stream << ifs.rdbuf();
ifs.close();
pimpl->contentNames.push_back(filename);
}
bool CSVAnswerSetPrinterCallback::operator()(
AnswerSetPtr as)
{
DLVHEX_BENCHMARK_REGISTER_AND_SCOPE(sid,"AnswerSetPrinterCallback");
// uses the Registry to print the interpretation, including
// possible influence from AuxiliaryPrinter objects (if any are registered)
Interpretation::Storage::enumerator it, it_end;
RegistryPtr reg = as->interpretation->getRegistry();
// must be in this scope!
Interpretation::Storage filteredbits;
assert( !!filterpm && "filter must always be defined in CSV format" );
filterpm->updateMask();
filteredbits =
as->interpretation->getStorage() & filterpm->mask()->getStorage();
it = filteredbits.first();
it_end = filteredbits.end();
std::ostream& o = std::cout;
if (!firstas) o << std::endl;
firstas = false;
typedef std::pair<IDAddress, IDAddress> OT;
std::vector<OT> output;
while( it != it_end ) {
const OrdinaryAtom& oatom = reg->ogatoms.getByAddress(*it);
if (oatom.tuple.size() < 3) throw GeneralError("Atoms which define CSV output must have an arity of 2 or greater.");
output.push_back(OT(oatom.tuple[1].address, *it));
++it;
}
std::sort(output.begin(), output.end());
bool first = true;
BOOST_FOREACH (OT outputElement, output){
const OrdinaryAtom& oatom = reg->ogatoms.getByAddress(outputElement.second);
if (!first) o << std::endl;
first = false;
for (int i = 2; i < oatom.tuple.size(); ++i) {
o << (i > 2 ? ";" : "");
if (oatom.tuple[i].isIntegerTerm()) o << oatom.tuple[i].address;
else o << reg->terms.getByID(oatom.tuple[i]).getUnquotedString();
}
}
o << std::endl;
// never abort
return true;
}
int DetailList::FindMaterial( char *name )
{
// search through our material list for the material with the
// given name, and if found, return the index, else return 0.
// (Not really, since if it's not found it is an error.)
for( int i = 0; i < fnMats; i++ )
{
if( !strcmp( name, faMats[i].fName ) )
return i;
}
throw GeneralError( "Undefined material in mesh!" );
return 0;
}
void StateSet::init_from_datafile(std::string filename) {
// open other file read-only
H5::H5File otherfile;
otherfile.openFile(filename, H5F_ACC_RDONLY);
H5::Group otherroot = otherfile.openGroup("/");
// check that grid properties match
int othersx, othersy, otherN;
double otherdx;
otherroot.openAttribute("num_states").read(H5::PredType::NATIVE_INT, &otherN);
otherroot.openAttribute("grid_sizex").read(H5::PredType::NATIVE_INT, &othersx);
otherroot.openAttribute("grid_sizex").read(H5::PredType::NATIVE_INT, &othersy);
otherroot.openAttribute("grid_delta").read(H5::PredType::NATIVE_DOUBLE, &otherdx);
if (static_cast<int>(N) != otherN)
throw GeneralError("Cannot copy state data from datafile: value for num_states does not match.");
if (static_cast<int>(datalayout.sizex) != othersx)
throw GeneralError("Cannot copy state data from datafile: value for grid_sizex does not match.");
if (static_cast<int>(datalayout.sizey) != othersy)
throw GeneralError("Cannot copy state data from datafile: value for grid_sizey does not match.");
if (datalayout.dx != otherdx)
throw GeneralError("Cannot copy state data from datafile: value for grid_delta does not match.");
// copy data
H5::DataSet other_states_data = otherfile.openDataSet("/states");
other_states_data.read(state_array->get_dataptr(), other_states_data.getArrayType());
}
void InputProvider::addURLInput(const std::string& url)
{
assert(url.find("http://") == 0 && "currently only processing http:// URLs");
URLBuf ubuf;
ubuf.open(url);
std::istream is(&ubuf);
pimpl->stream << is.rdbuf();
if (ubuf.responsecode() == 404) {
throw GeneralError("Requested URL " + url + " was not found");
}
pimpl->contentNames.push_back(url);
}
void McEnvironment::parseFiles(const std::vector<std::string>& input_files) {
/* Check if there is a parser on the environment */
if (!parser)
throw(GeneralError("Attempt to parse a file without a parser loaded on the environment"));
/* Parse information */
for(vector<string>::const_iterator it = input_files.begin() ; it != input_files.end() ; ++it)
parser->parseFile((*it));
/* Get parsed objects */
vector<McObject*> objects = parser->getObjects();
/* Put the objects on the map */
for(vector<McObject*>::iterator it = objects.begin() ; it != objects.end() ; ++it) {
/* Set the environment where this object is passing through */
(*it)->setEnvironment(this);
object_map[(*it)->getModuleName()].push_back((*it));
}
}
// Return the inverse transform corresponding to a transform.
Transform inverse_transform_of(Transform trans) {
switch (trans) {
case FFT:
return iFFT;
case iFFT:
return FFT;
case FFTx:
return iFFTx;
case iFFTx:
return FFTx;
case FFTy:
return iFFTy;
case iFFTy:
return FFTy;
case DST:
return iDST;
case iDST:
return DST;
case DSTx:
return iDSTx;
case iDSTx:
return DSTx;
case DSTy:
return iDSTy;
case iDSTy:
return DSTy;
case DCT:
return iDCT;
case iDCT:
return DCT;
case DCTx:
return iDCTx;
case iDCTx:
return DCTx;
case DCTy:
return iDCTy;
case iDCTy:
return DCTy;
default:
throw GeneralError("Switch statement at inverse_transform_of ended up where it never should.");
return iFFT;
}
}
/* Sample particle (and check cell) */
void ParticleCellSampler::operator() (CellParticle& particle,Random& r) const {
/* Number of samples */
size_t nsamples = 0;
/* Flag if is inside the cell */
bool inside = false;
/* First get the position (rejecting point outside the cell) */
while(!inside) {
/* Initial position for sampling */
particle.second.pos() = position;
/* Apply position distributions */
for(vector<DistributionBase*>::const_iterator it = pos_distributions.begin() ; it != pos_distributions.end() ; ++it)
(*(*it))(particle.second,r);
/* Check if we are inside the cell */
for(vector<Cell*>::const_iterator it = cells.begin() ; it != cells.end() ; ++it) {
/* Get cell */
const Cell* cell = (*it)->findCell(particle.second.pos());
if(cell) {
/* Is inside */
inside = true;
/* Set the cell */
particle.first = cell;
/* Break loop */
break;
}
}
/* Count sample */
nsamples++;
if(nsamples >= max_samples)
throw(GeneralError("Sampler efficiency too low on sampler " + getUserId() +
". Please, reconsider the source definition because this is not a fair game"));
}
/* Once the position is set, set phase space coordinates of this sampler */
particle.second.dir() = direction;
particle.second.erg() = energy;
particle.second.wgt() = weight;
/* Apply distributions (if any) */
for(vector<DistributionBase*>::const_iterator it = distributions.begin() ; it != distributions.end() ; ++it)
(*(*it))(particle.second,r);
}
void DetailList::AddMaterial( Material &m )
{
char s[100];
// handle too many materials:
if( fnMats == MAX_MATS )
throw GeneralError( "Too many materials!" );
// handle duplicate materials:
for( int i = 0; i < fnMats; i++ )
if( !strcmp( m.fName, faMats[i].fName ) )
{
if( !(faMats[i] == m) )
{
sprintf( s, "Material '%s' conflicts with prior material '%s'",
m.fName, faMats[i].fName );
throw GeneralError( s );
}
// identical duplicate found
// return without adding duplicate:
return;
}
// if textured, get the actual texture bitmap and add to sheets:
if( m.fTextured )
{
strcpy( m.fTextureFile, m.fRawTextureFile );
GFXBitmap * pBmp = GFXBitmap::load( m.fRawTextureFile );
if( pBmp )
{
// if texture is translucent, pack the alpha info into it:
if( m.fTextureHasAlpha )
{
GFXBitmap *pAlpha = GFXBitmap::load( m.fAlphaFile );
if( !pAlpha )
{
delete pBmp;
sprintf( s, "Alpha file missing: '%s'", m.fAlphaFile );
throw GeneralError( s );
}
Alphatize( pBmp, pAlpha );
delete pAlpha;
// save alphatized bitmap with .pab extension:
if( strchr( m.fTextureFile, '.' ) )
strcpy( strchr( m.fTextureFile, '.' ), ".pab" );
else
strcat( m.fTextureFile, ".pab" );
pBmp->write( m.fTextureFile );
}
m.fTransparent = IsTransparent( pBmp );
delete pBmp;
}
else
{
sprintf( s, "Texture file missing: '%s'", m.fRawTextureFile );
throw GeneralError( s );
}
}
// See if TSMaterial is identical to another:
m.MakeTSMaterial( &faTSMats[fnTSMats] );
for( int tm = 0; tm < fnTSMats; tm++ )
if( !memcmp( &m, &faTSMats[tm], sizeof( TSMaterial ) ) )
{
// if same as a previous TSMaterial, don't duplicate
m.fTSMaterialIndex = tm;
break;
}
// allow no duplicates in TSMaterials:
if( m.fTSMaterialIndex == -1 )
m.fTSMaterialIndex = fnTSMats++;
// add all materials here which are unique (if only by name) in 3dStudio:
faMats[fnMats++] = m;
// display material attributes:
//m.Dump();
}
void ExtSourceProperties::interpretProperties(RegistryPtr reg, const ExternalAtom& atom, const std::vector<std::vector<std::string> >& props)
{
DBGLOG(DBG, "Interpreting external source properties");
typedef std::vector<std::string> Prop;
BOOST_FOREACH (Prop p, props) {
// parameter interpretation
ID param1 = ID_FAIL;
ID param2 = ID_FAIL;
if (p.size() > 1) {
try
{
param1 = ID::termFromInteger(boost::lexical_cast<int>(p[1]));
}
catch(boost::bad_lexical_cast&) {
param1 = reg->storeConstantTerm(p[1]);
}
}
if (p.size() > 2) {
try
{
param2 = ID::termFromInteger(boost::lexical_cast<int>(p[2]));
}
catch(boost::bad_lexical_cast&) {
param2 = reg->storeConstantTerm(p[2]);
}
}
// property interpretation
std::string name = p[0];
if (name == "functional") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"functional\" expects no parameters");
DBGLOG(DBG, "External Atom is functional");
functional = true;
}
else if (name == "monotonic") {
if (param2 != ID_FAIL) throw GeneralError("Property \"monotonic\" expects less than two parameters");
if (param1 == ID_FAIL) {
DBGLOG(DBG, "External Atom is monotonic in all input parameters");
for (uint32_t i = 0; i < atom.inputs.size(); ++i) {
monotonicInputPredicates.insert(i);
}
}
else {
bool found = false;
for (uint32_t i = 0; i < atom.inputs.size(); ++i) {
if (atom.inputs[i] == param1) {
DBGLOG(DBG, "External Atom is monotonic in parameter " << i);
monotonicInputPredicates.insert(i);
found = true;
break;
}
}
if (!found) throw SyntaxError("Property refers to invalid input parameter");
}
}
else if (name == "antimonotonic") {
if (param2 != ID_FAIL) throw GeneralError("Property \"antimonotonic\" expects less than two parameters");
if (param1 == ID_FAIL) {
DBGLOG(DBG, "External Atom is antimonotonic in all input parameters");
for (uint32_t i = 0; i < atom.inputs.size(); ++i) {
antimonotonicInputPredicates.insert(i);
}
}
else {
bool found = false;
for (uint32_t i = 0; i < atom.inputs.size(); ++i) {
if (atom.inputs[i] == param1) {
DBGLOG(DBG, "External Atom is antimonotonic in parameter " << i);
antimonotonicInputPredicates.insert(i);
found = true;
break;
}
}
if (!found) throw SyntaxError("Property refers to invalid input parameter");
}
}
else if (name == "atomlevellinear" || name == "fullylinear") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"atomlevellinear\" expects no parameters");
DBGLOG(DBG, "External Atom is linear on atom level");
atomlevellinear = true;
}
else if (name == "tuplelevellinear") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"tuplelevellinear\" expects no parameters");
DBGLOG(DBG, "External Atom is linear on tuple level");
tuplelevellinear = true;
}
else if (name == "usesenvironment") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"usesenvironment\" expects no parameters");
DBGLOG(DBG, "External Atom uses environment");
usesEnvironment = true;
}
else if (name == "finitedomain") {
if (param2 != ID_FAIL) throw GeneralError("Property \"finitedomain\" expects less than two parameters");
if (param1 == ID_FAIL) {
DBGLOG(DBG, "External Atom has a finite domain in all output positions");
for (uint32_t i = 0; i < atom.tuple.size(); ++i) {
finiteOutputDomain.insert(i);
}
}
else {
bool found = false;
if (!param1.isIntegerTerm()) throw GeneralError("The parameter of property \"finitedomain\" must be an integer");
finiteOutputDomain.insert(param1.address);
}
}
else if (name == "relativefinitedomain") {
if (param1 == ID_FAIL || param2 == ID_FAIL) throw GeneralError("Property \"relativefinitedomain\" expects two parameters");
int wrt;
bool found = false;
for (uint32_t i = 0; i < atom.inputs.size(); ++i) {
if (atom.inputs[i] == param2) {
wrt = i;
found = true;
break;
}
}
if (!found) throw SyntaxError("Property refers to invalid input parameter");
if (!param1.isIntegerTerm()) throw GeneralError("The first parameter of property \"relativefinitedomain\" must be an integer");
relativeFiniteOutputDomain.insert(std::pair<int, int>(param1.address, wrt));
}
else if (name == "finitefiber") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"finitefiber\" expects no parameters");
DBGLOG(DBG, "External Atom has a finite fiber");
finiteFiber = true;
}
else if (name == "wellorderingstrlen") {
if (param1 == ID_FAIL || param2 == ID_FAIL) throw GeneralError("Property \"wellordering\" expects two parameters");
DBGLOG(DBG, "External Atom has a wellordering using strlen");
wellorderingStrlen.insert(std::pair<int, int>(param1.address, param2.address));
}
else if (name == "wellordering") {
if (param1 == ID_FAIL || param2 == ID_FAIL) throw GeneralError("Property \"wellordering\" expects two parameters");
DBGLOG(DBG, "External Atom has a wellordering using natural");
wellorderingNatural.insert(std::pair<int, int>(param1.address, param2.address));
}
else if (name == "supportsets") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"supportsets\" expects no parameters");
DBGLOG(DBG, "External Atom provides support sets");
supportSets = true;
}
else if (name == "completepositivesupportsets") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"completepositivesupportsets\" expects no parameters");
DBGLOG(DBG, "External Atom provides complete positive support sets");
supportSets = true;
completePositiveSupportSets = true;
}
else if (name == "completenegativesupportsets") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"completepositivesupportsets\" expects no parameters");
DBGLOG(DBG, "External Atom provides complete negative support sets");
supportSets = true;
completeNegativeSupportSets = true;
}
else if (name == "variableoutputarity") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"variableoutputarity\" expects no parameters");
DBGLOG(DBG, "External Atom has a variable output arity");
variableOutputArity = true;
}
else if (name == "caresaboutassigned") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"caresaboutassigned\" expects no parameters");
DBGLOG(DBG, "External Atom cares about assigned atoms");
caresAboutAssigned = true;
}
else if (name == "caresaboutchanged") {
if (param1 != ID_FAIL || param2 != ID_FAIL) throw GeneralError("Property \"caresaboutchanged\" expects no parameters");
DBGLOG(DBG, "External Atom has a variable output arity");
caresAboutChanged = true;
}
else {
throw SyntaxError("Property \"" + name + "\" unrecognized");
}
}
