2016-06-10 17:40:32 +02:00
|
|
|
#include <plasp/pddl/TranslatorASP.h>
|
|
|
|
|
2016-06-12 23:38:44 +02:00
|
|
|
#include <plasp/pddl/expressions/And.h>
|
|
|
|
#include <plasp/pddl/expressions/Not.h>
|
2016-06-13 02:38:56 +02:00
|
|
|
#include <plasp/pddl/expressions/Predicate.h>
|
2016-06-12 22:25:12 +02:00
|
|
|
#include <plasp/utils/IO.h>
|
2016-06-10 17:40:32 +02:00
|
|
|
#include <plasp/utils/TranslatorException.h>
|
|
|
|
|
|
|
|
namespace plasp
|
|
|
|
{
|
|
|
|
namespace pddl
|
|
|
|
{
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// TranslatorASP
|
|
|
|
//
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2016-06-12 22:31:18 +02:00
|
|
|
TranslatorASP::TranslatorASP(const Description &description, std::ostream &ostream)
|
|
|
|
: m_description(description),
|
|
|
|
m_ostream(ostream)
|
2016-06-10 17:40:32 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2016-06-12 22:19:55 +02:00
|
|
|
void TranslatorASP::checkSupport() const
|
|
|
|
{
|
2016-06-12 23:38:44 +02:00
|
|
|
// Check for "either" types in predicate declarations
|
2016-06-12 22:19:55 +02:00
|
|
|
const auto &predicates = m_description.domain().predicates();
|
|
|
|
|
|
|
|
std::for_each(predicates.cbegin(), predicates.cend(),
|
|
|
|
[&](const auto &predicate)
|
|
|
|
{
|
|
|
|
const auto &arguments = predicate->arguments();
|
|
|
|
|
|
|
|
std::for_each(arguments.cbegin(), arguments.cend(),
|
|
|
|
[&](const auto ¶meter)
|
|
|
|
{
|
|
|
|
if (parameter->type()->expressionType() != Expression::Type::PrimitiveType)
|
|
|
|
throw utils::TranslatorException("Only primitive types supported currently");
|
|
|
|
});
|
|
|
|
});
|
2016-06-12 22:47:39 +02:00
|
|
|
|
|
|
|
const auto &actions = m_description.domain().actions();
|
|
|
|
|
|
|
|
std::for_each(actions.cbegin(), actions.cend(),
|
|
|
|
[&](const auto &action)
|
|
|
|
{
|
|
|
|
const auto ¶meters = action->parameters();
|
|
|
|
|
2016-06-12 23:38:44 +02:00
|
|
|
// Check for "either" types in action parameters
|
2016-06-12 22:47:39 +02:00
|
|
|
std::for_each(parameters.cbegin(), parameters.cend(),
|
|
|
|
[&](const auto ¶meter)
|
|
|
|
{
|
|
|
|
if (parameter->type()->expressionType() != Expression::Type::PrimitiveType)
|
|
|
|
throw utils::TranslatorException("Only primitive types supported currently");
|
|
|
|
});
|
2016-06-12 23:38:44 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
if (action->precondition())
|
2016-06-12 23:38:44 +02:00
|
|
|
{
|
2016-06-13 02:38:56 +02:00
|
|
|
// Check that all preconditions are "and" expressions or single predicates
|
|
|
|
if (action->precondition()->expressionType() != Expression::Type::And
|
|
|
|
&& action->precondition()->expressionType() != Expression::Type::Predicate)
|
|
|
|
{
|
|
|
|
throw utils::TranslatorException("Only \"and\" expressions and single predicates supported as action preconditions currently");
|
|
|
|
}
|
2016-06-12 23:38:44 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
// Check that "and" expression in preconditions contains single predicates only
|
|
|
|
if (action->precondition()->expressionType() == Expression::Type::And)
|
|
|
|
{
|
|
|
|
const auto &precondition = dynamic_cast<const expressions::And &>(*action->precondition());
|
|
|
|
const auto &preconditionArguments = precondition.arguments();
|
2016-06-12 23:38:44 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
std::for_each(preconditionArguments.cbegin(), preconditionArguments.cend(),
|
|
|
|
[&](const auto &argument)
|
|
|
|
{
|
|
|
|
if (argument->expressionType() != Expression::Type::Predicate)
|
|
|
|
throw utils::TranslatorException("Only predicates supported in preconditions currently");
|
|
|
|
});
|
|
|
|
}
|
2016-06-12 23:38:44 +02:00
|
|
|
}
|
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
if (action->effect())
|
2016-06-12 23:38:44 +02:00
|
|
|
{
|
2016-06-13 02:38:56 +02:00
|
|
|
// Check that all effects are "and" expressions
|
|
|
|
if (action->effect()->expressionType() != Expression::Type::And
|
|
|
|
&& action->effect()->expressionType() != Expression::Type::Predicate)
|
|
|
|
{
|
|
|
|
throw utils::TranslatorException("Only \"and\" expressions and single predicates supported as action effects currently");
|
|
|
|
}
|
2016-06-12 23:38:44 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
// Check that "and" expression in effect contains single predicates or negated predicates only
|
|
|
|
if (action->effect()->expressionType() == Expression::Type::And)
|
|
|
|
{
|
|
|
|
const auto &effect = dynamic_cast<const expressions::And &>(*action->effect());
|
|
|
|
const auto &effectArguments = effect.arguments();
|
2016-06-12 23:38:44 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
std::for_each(effectArguments.cbegin(), effectArguments.cend(),
|
|
|
|
[&](const auto *argument)
|
2016-06-12 23:38:44 +02:00
|
|
|
{
|
2016-06-13 02:38:56 +02:00
|
|
|
if (argument->expressionType() == Expression::Type::Not)
|
|
|
|
{
|
|
|
|
const auto ¬Expression = dynamic_cast<const expressions::Not &>(*argument);
|
|
|
|
argument = notExpression.argument();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (argument->expressionType() != Expression::Type::Predicate)
|
|
|
|
throw utils::TranslatorException("Only predicates and negated predicates supported in effects currently");
|
|
|
|
});
|
|
|
|
}
|
2016-06-12 23:38:44 +02:00
|
|
|
}
|
2016-06-12 22:47:39 +02:00
|
|
|
});
|
2016-06-12 22:19:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2016-06-12 22:31:18 +02:00
|
|
|
void TranslatorASP::translate() const
|
2016-06-10 17:40:32 +02:00
|
|
|
{
|
2016-06-12 22:19:55 +02:00
|
|
|
checkSupport();
|
|
|
|
|
2016-06-12 22:31:18 +02:00
|
|
|
translateDomain();
|
2016-06-10 17:40:32 +02:00
|
|
|
|
|
|
|
if (m_description.containsProblem())
|
2016-06-12 22:25:12 +02:00
|
|
|
{
|
2016-06-12 22:31:18 +02:00
|
|
|
m_ostream << std::endl;
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:31:18 +02:00
|
|
|
translateProblem();
|
2016-06-12 22:25:12 +02:00
|
|
|
}
|
2016-06-10 17:40:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2016-06-12 22:31:18 +02:00
|
|
|
void TranslatorASP::translateDomain() const
|
2016-06-10 17:40:32 +02:00
|
|
|
{
|
2016-06-12 22:31:18 +02:00
|
|
|
m_ostream
|
2016-06-10 17:40:32 +02:00
|
|
|
<< "%---------------------------------------" << std::endl
|
|
|
|
<< "% domain" << std::endl
|
2016-06-10 17:52:19 +02:00
|
|
|
<< "%---------------------------------------" << std::endl;
|
2016-06-10 17:40:32 +02:00
|
|
|
|
|
|
|
const auto &domain = m_description.domain();
|
|
|
|
|
|
|
|
// Types
|
2016-06-12 22:19:24 +02:00
|
|
|
if (!domain.types().empty())
|
|
|
|
{
|
2016-06-12 22:31:18 +02:00
|
|
|
m_ostream << std::endl;
|
2016-06-12 22:39:04 +02:00
|
|
|
translateTypes();
|
2016-06-12 22:19:24 +02:00
|
|
|
}
|
2016-06-10 17:52:19 +02:00
|
|
|
|
|
|
|
// Constants
|
2016-06-12 22:19:24 +02:00
|
|
|
if (!domain.constants().empty())
|
|
|
|
{
|
2016-06-12 22:31:18 +02:00
|
|
|
m_ostream << std::endl;
|
2016-06-12 22:39:04 +02:00
|
|
|
translateConstants();
|
2016-06-12 22:19:24 +02:00
|
|
|
}
|
2016-06-12 22:25:12 +02:00
|
|
|
|
|
|
|
// Predicates
|
|
|
|
if (!domain.predicates().empty())
|
|
|
|
{
|
2016-06-12 22:31:18 +02:00
|
|
|
m_ostream << std::endl;
|
2016-06-12 22:39:04 +02:00
|
|
|
translatePredicates();
|
|
|
|
}
|
2016-06-12 22:47:39 +02:00
|
|
|
|
|
|
|
// Actions
|
|
|
|
if (!domain.actions().empty())
|
|
|
|
{
|
|
|
|
m_ostream << std::endl;
|
|
|
|
translateActions();
|
|
|
|
}
|
2016-06-12 22:39:04 +02:00
|
|
|
}
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
void TranslatorASP::translateTypes() const
|
|
|
|
{
|
2016-06-12 22:47:39 +02:00
|
|
|
// TODO: escape ASP identifiers
|
2016-06-12 22:39:04 +02:00
|
|
|
m_ostream << "% types";
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
const auto &types = m_description.domain().types();
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
std::for_each(types.cbegin(), types.cend(),
|
|
|
|
[&](const auto &type)
|
|
|
|
{
|
|
|
|
m_ostream << std::endl;
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
m_ostream << "type(" << type->name() << ")." << std::endl;
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
const auto &parentTypes = type->parentTypes();
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
std::for_each(parentTypes.cbegin(), parentTypes.cend(),
|
|
|
|
[&](const auto &parentType)
|
2016-06-12 22:25:12 +02:00
|
|
|
{
|
2016-06-12 22:39:04 +02:00
|
|
|
m_ostream << "inherits(type(" << type->name() << "), type(" << parentType->name() << "))." << std::endl;
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
void TranslatorASP::translateConstants() const
|
|
|
|
{
|
|
|
|
m_ostream << "% constants";
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
const auto &constants = m_description.domain().constants();
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
std::for_each(constants.cbegin(), constants.cend(),
|
|
|
|
[&](const auto &constant)
|
|
|
|
{
|
|
|
|
m_ostream << std::endl;
|
2016-06-12 22:25:12 +02:00
|
|
|
|
2016-06-12 22:39:04 +02:00
|
|
|
m_ostream << "constant(" << constant->name() << ")." << std::endl;
|
|
|
|
|
|
|
|
const auto *type = constant->type();
|
|
|
|
|
|
|
|
if (type == nullptr)
|
|
|
|
return;
|
|
|
|
|
|
|
|
m_ostream << "hasType(constant(" << constant->name() << "), type(" << type->name() << "))." << std::endl;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
void TranslatorASP::translatePredicates() const
|
|
|
|
{
|
|
|
|
m_ostream << "% predicates";
|
|
|
|
|
|
|
|
const auto &predicates = m_description.domain().predicates();
|
|
|
|
|
|
|
|
std::for_each(predicates.cbegin(), predicates.cend(),
|
|
|
|
[&](const auto &predicate)
|
|
|
|
{
|
|
|
|
m_ostream << std::endl;
|
|
|
|
|
|
|
|
m_ostream << "predicate(" << predicate->name();
|
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
this->translateVariablesHead(predicate->arguments());
|
|
|
|
|
|
|
|
m_ostream << ")";
|
|
|
|
|
|
|
|
this->translateVariablesBody(predicate->arguments());
|
2016-06-12 22:39:04 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
m_ostream << ".";
|
2016-06-12 22:39:04 +02:00
|
|
|
});
|
2016-06-12 22:47:39 +02:00
|
|
|
|
|
|
|
m_ostream << std::endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
void TranslatorASP::translateActions() const
|
|
|
|
{
|
|
|
|
m_ostream << "% actions";
|
|
|
|
|
|
|
|
const auto &actions = m_description.domain().actions();
|
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
const auto printActionName =
|
|
|
|
[&](const auto &action)
|
|
|
|
{
|
|
|
|
m_ostream << "action(" << action.name();
|
|
|
|
|
|
|
|
this->translateVariablesHead(action.parameters());
|
|
|
|
|
|
|
|
m_ostream << ")";
|
|
|
|
};
|
|
|
|
|
2016-06-12 22:47:39 +02:00
|
|
|
std::for_each(actions.cbegin(), actions.cend(),
|
|
|
|
[&](const auto &action)
|
|
|
|
{
|
|
|
|
m_ostream << std::endl;
|
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
// Name
|
|
|
|
printActionName(*action);
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
this->translateVariablesBody(action->parameters());
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
m_ostream << ".";
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
const auto translateLiteral =
|
|
|
|
[&](const auto &ruleHead, const auto &literal)
|
|
|
|
{
|
|
|
|
m_ostream << std::endl;
|
|
|
|
m_ostream << ruleHead << "(";
|
|
|
|
|
|
|
|
printActionName(*action);
|
|
|
|
|
|
|
|
m_ostream << ", ";
|
|
|
|
|
|
|
|
// Translate single predicate
|
|
|
|
if (literal.expressionType() == Expression::Type::Predicate)
|
|
|
|
{
|
|
|
|
this->translatePredicate(dynamic_cast<const expressions::Predicate &>(literal));
|
|
|
|
m_ostream << ", true";
|
|
|
|
}
|
|
|
|
// Assuming that "not" expression may only contain a predicate
|
|
|
|
else if (literal.expressionType() == Expression::Type::Not)
|
|
|
|
{
|
|
|
|
const auto ¬Expression = dynamic_cast<const expressions::Not &>(literal);
|
|
|
|
const auto &predicate = dynamic_cast<const expressions::Predicate &>(*notExpression.argument());
|
|
|
|
|
|
|
|
this->translatePredicate(predicate);
|
|
|
|
m_ostream << ", false";
|
|
|
|
}
|
|
|
|
|
|
|
|
m_ostream << ") :- ";
|
|
|
|
|
|
|
|
printActionName(*action);
|
|
|
|
|
|
|
|
m_ostream << ".";
|
|
|
|
};
|
|
|
|
|
|
|
|
// Precondition
|
|
|
|
if (action->precondition())
|
|
|
|
{
|
|
|
|
const auto &precondition = *action->precondition();
|
|
|
|
|
|
|
|
if (precondition.expressionType() == Expression::Type::Predicate
|
|
|
|
|| precondition.expressionType() == Expression::Type::Not)
|
|
|
|
{
|
|
|
|
translateLiteral("precondition", precondition);
|
|
|
|
}
|
|
|
|
// Assuming a conjunction
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const auto &andExpression = dynamic_cast<const expressions::And &>(precondition);
|
|
|
|
|
|
|
|
std::for_each(andExpression.arguments().cbegin(), andExpression.arguments().cend(),
|
|
|
|
[&](const auto *argument)
|
|
|
|
{
|
|
|
|
translateLiteral("precondition", *argument);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-13 02:41:23 +02:00
|
|
|
// Effect
|
|
|
|
if (action->effect())
|
|
|
|
{
|
|
|
|
const auto &effect = *action->effect();
|
|
|
|
|
|
|
|
if (effect.expressionType() == Expression::Type::Predicate
|
|
|
|
|| effect.expressionType() == Expression::Type::Not)
|
|
|
|
{
|
|
|
|
translateLiteral("postcondition", effect);
|
|
|
|
}
|
|
|
|
// Assuming a conjunction
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const auto &andExpression = dynamic_cast<const expressions::And &>(effect);
|
|
|
|
|
|
|
|
std::for_each(andExpression.arguments().cbegin(), andExpression.arguments().cend(),
|
|
|
|
[&](const auto *argument)
|
|
|
|
{
|
|
|
|
translateLiteral("postcondition", *argument);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
m_ostream << std::endl;
|
|
|
|
});
|
2016-06-12 22:55:35 +02:00
|
|
|
}
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-12 22:55:35 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
void TranslatorASP::translateVariablesHead(const expressions::Variables &variables) const
|
2016-06-12 22:55:35 +02:00
|
|
|
{
|
|
|
|
if (variables.empty())
|
|
|
|
return;
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-12 22:55:35 +02:00
|
|
|
m_ostream << "(";
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-12 22:55:35 +02:00
|
|
|
for (auto i = variables.cbegin(); i != variables.cend(); i++)
|
|
|
|
{
|
|
|
|
if (i != variables.cbegin())
|
|
|
|
m_ostream << ", ";
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-12 22:55:35 +02:00
|
|
|
const auto &variable = *dynamic_cast<const expressions::Variable *>(i->get());
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-12 22:55:35 +02:00
|
|
|
m_ostream << utils::escapeASPVariable(variable.name());
|
|
|
|
}
|
2016-06-12 22:47:39 +02:00
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
m_ostream << ")";
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
void TranslatorASP::translateVariablesBody(const expressions::Variables &variables) const
|
|
|
|
{
|
|
|
|
if (variables.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
m_ostream << " :- ";
|
2016-06-12 22:55:35 +02:00
|
|
|
|
|
|
|
for (auto i = variables.cbegin(); i != variables.cend(); i++)
|
|
|
|
{
|
|
|
|
if (i != variables.cbegin())
|
|
|
|
m_ostream << ", ";
|
|
|
|
|
|
|
|
const auto &variable = *dynamic_cast<const expressions::Variable *>(i->get());
|
|
|
|
const auto &type = *dynamic_cast<const expressions::PrimitiveType *>(variable.type());
|
|
|
|
|
|
|
|
m_ostream << "hasType(" << utils::escapeASPVariable(variable.name()) << ", type(" << type.name() << "))";
|
|
|
|
}
|
2016-06-10 17:40:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2016-06-13 02:38:56 +02:00
|
|
|
void TranslatorASP::translatePredicate(const expressions::Predicate &predicate) const
|
|
|
|
{
|
|
|
|
m_ostream << "predicate(" << predicate.name();
|
|
|
|
|
|
|
|
const auto &arguments = predicate.arguments();
|
|
|
|
|
|
|
|
if (arguments.empty())
|
|
|
|
{
|
|
|
|
m_ostream << ")";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_ostream << "(";
|
|
|
|
|
|
|
|
for (auto i = arguments.cbegin(); i != arguments.cend(); i++)
|
|
|
|
{
|
|
|
|
if (i != arguments.cbegin())
|
|
|
|
m_ostream << ", ";
|
|
|
|
|
|
|
|
if ((*i)->expressionType() == Expression::Type::Constant)
|
|
|
|
{
|
|
|
|
const auto &constant = dynamic_cast<const expressions::Constant &>(**i);
|
|
|
|
|
|
|
|
m_ostream << "constant(" << constant.name() << ")";
|
|
|
|
}
|
|
|
|
else if ((*i)->expressionType() == Expression::Type::Variable)
|
|
|
|
{
|
|
|
|
const auto &variable = dynamic_cast<const expressions::Variable &>(**i);
|
|
|
|
|
|
|
|
m_ostream << utils::escapeASPVariable(variable.name());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
throw utils::TranslatorException("Only variables and constants supported in predicates");
|
|
|
|
}
|
|
|
|
|
|
|
|
m_ostream << "))";
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2016-06-12 22:31:18 +02:00
|
|
|
void TranslatorASP::translateProblem() const
|
2016-06-10 17:40:32 +02:00
|
|
|
{
|
2016-06-12 22:47:39 +02:00
|
|
|
m_ostream
|
2016-06-10 17:40:32 +02:00
|
|
|
<< "%---------------------------------------" << std::endl
|
|
|
|
<< "% problem" << std::endl
|
2016-06-10 17:52:19 +02:00
|
|
|
<< "%---------------------------------------" << std::endl;
|
2016-06-10 17:40:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|