void TreeBuilder::AddRandomChildren(
Node& node, bool bUseTerminal, bool bUseNode, unsigned int nDepth, unsigned int nMaxDepth ) {
assert( bUseTerminal || bUseNode ); // use one or both
assert( nDepth <= nMaxDepth );
NodeType::E nt( node.ChildType() );
switch ( node.NodeCount() ) {
case 0: // nothing, this is terminal node
assert( node.IsTerminal() );
break;
case 1:
node.AddCenter( CreateChild( nt, bUseTerminal, bUseNode, nDepth, nMaxDepth ) );
if ( !node.ChildCenter().IsTerminal() ) {
AddRandomChildren( node.ChildCenter(), bUseTerminal, bUseNode, nDepth + 1, nMaxDepth );
}
break;
case 2:
node.AddLeft( CreateChild( nt, bUseTerminal, bUseNode, nDepth, nMaxDepth ) );
if ( !node.ChildLeft().IsTerminal() ) {
AddRandomChildren( node.ChildLeft(), bUseTerminal, bUseNode, nDepth + 1, nMaxDepth );
}
node.AddRight( CreateChild( nt, bUseTerminal, bUseNode, nDepth, nMaxDepth ) );
if ( !node.ChildRight().IsTerminal() ) {
AddRandomChildren( node.ChildRight(), bUseTerminal, bUseNode, nDepth + 1, nMaxDepth );
}
break;
}
}
nsresult
txStylesheet::init()
{
mRootFrame = new ImportFrame;
NS_ENSURE_TRUE(mRootFrame, NS_ERROR_OUT_OF_MEMORY);
// Create default templates
// element/root template
mContainerTemplate = new txPushParams;
NS_ENSURE_TRUE(mContainerTemplate, NS_ERROR_OUT_OF_MEMORY);
nsAutoPtr<txNodeTest> nt(new txNodeTypeTest(txNodeTypeTest::NODE_TYPE));
NS_ENSURE_TRUE(nt, NS_ERROR_OUT_OF_MEMORY);
nsAutoPtr<Expr> nodeExpr(new LocationStep(nt, LocationStep::CHILD_AXIS));
NS_ENSURE_TRUE(nodeExpr, NS_ERROR_OUT_OF_MEMORY);
nt.forget();
txPushNewContext* pushContext = new txPushNewContext(nodeExpr);
mContainerTemplate->mNext = pushContext;
NS_ENSURE_TRUE(pushContext, NS_ERROR_OUT_OF_MEMORY);
txApplyDefaultElementTemplate* applyTemplates =
new txApplyDefaultElementTemplate;
pushContext->mNext = applyTemplates;
NS_ENSURE_TRUE(applyTemplates, NS_ERROR_OUT_OF_MEMORY);
txLoopNodeSet* loopNodeSet = new txLoopNodeSet(applyTemplates);
applyTemplates->mNext = loopNodeSet;
NS_ENSURE_TRUE(loopNodeSet, NS_ERROR_OUT_OF_MEMORY);
txPopParams* popParams = new txPopParams;
pushContext->mBailTarget = loopNodeSet->mNext = popParams;
NS_ENSURE_TRUE(popParams, NS_ERROR_OUT_OF_MEMORY);
popParams->mNext = new txReturn();
NS_ENSURE_TRUE(popParams->mNext, NS_ERROR_OUT_OF_MEMORY);
// attribute/textnode template
nt = new txNodeTypeTest(txNodeTypeTest::NODE_TYPE);
NS_ENSURE_TRUE(nt, NS_ERROR_OUT_OF_MEMORY);
nodeExpr = new LocationStep(nt, LocationStep::SELF_AXIS);
NS_ENSURE_TRUE(nodeExpr, NS_ERROR_OUT_OF_MEMORY);
nt.forget();
mCharactersTemplate = new txValueOf(nodeExpr, false);
NS_ENSURE_TRUE(mCharactersTemplate, NS_ERROR_OUT_OF_MEMORY);
mCharactersTemplate->mNext = new txReturn();
NS_ENSURE_TRUE(mCharactersTemplate->mNext, NS_ERROR_OUT_OF_MEMORY);
// pi/comment/namespace template
mEmptyTemplate = new txReturn();
NS_ENSURE_TRUE(mEmptyTemplate, NS_ERROR_OUT_OF_MEMORY);
return NS_OK;
}
void tool_app_t::static_compile()
{
netlist_tool_t nt(*this, "netlist");
nt.init();
nt.log().verbose.set_enabled(false);
nt.log().info.set_enabled(false);
nt.read_netlist(opt_file(), opt_name(),
opt_logs(),
m_options, opt_rfolders());
// no reset needed ...
plib::putf8_writer w(&pout_strm);
std::map<pstring, pstring> mp;
nt.solver()->create_solver_code(mp);
for (auto &e : mp)
{
w.write(e.second);
}
nt.stop();
}
//=============================================================================
// Book cluster tuple
//=============================================================================
void TbTupleWriter::bookClusters() {
NTupleFilePtr file1(ntupleSvc(), "/NTUPLES/FILE1");
NTuplePtr nt(ntupleSvc(), "/NTUPLES/FILE1/TbTupleWriter/Clusters");
// Check if already booked.
if (nt) return;
nt = ntupleSvc()->book("/NTUPLES/FILE1/TbTupleWriter/Clusters",
CLID_ColumnWiseTuple, "nTuple of Clusters");
nt->addItem("clID", m_clID);
nt->addItem("clGx", m_clGx);
nt->addItem("clGy", m_clGy);
nt->addItem("clGz", m_clGz);
nt->addItem("clLx", m_clLx);
nt->addItem("clLy", m_clLy);
nt->addItem("clTime", m_clTime);
nt->addItem("clHTime", m_clHTime);
nt->addItem("clSize", m_clSize);
nt->addItem("clCharge", m_clCharge);
nt->addItem("clIsTracked", m_clTracked);
nt->addItem("clPlane", m_clPlane);
nt->addItem("clEvtNo", m_clEvtNo);
nt->addItem("clNHits", m_clN, 0, (int)m_maxclustersize);
nt->addIndexedItem("hRow", m_clN, m_clhRow);
nt->addIndexedItem("hCol", m_clN, m_clhCol);
nt->addIndexedItem("sCol", m_clN, m_clsCol);
nt->addIndexedItem("hHTime", m_clN, m_clhHTime);
nt->addIndexedItem("hToT", m_clN, m_clhToT);
}
solver::result smt2_output_wrapper::check() {
set_name_transformer nt(d_tm);
d_output << "(check-sat)" << std::endl;
return d_solver->check();
}
smt2_output_wrapper::smt2_output_wrapper(expr::term_manager& tm, const options& opts, utils::statistics& stats, solver* solver, std::string filename)
: smt::solver("smt2_wrapper[" + filename + "]", tm, opts, stats)
, d_solver(solver)
, d_output(filename.c_str())
, d_total_assertions_count(0)
{
set_name_transformer nt(d_tm);
// Setup the stream
output::set_output_language(d_output, output::MCMT);
output::set_term_manager(d_output, &d_tm);
// Models by default
d_output << "(set-option :produce-models true)" << std::endl;
// Unsat cores if supported
if (solver->supports(solver::UNSAT_CORE)) {
d_output << "(set-option :produce-unsat-cores true)" << std::endl;
}
// Interpolation if supported
if (solver->supports(solver::INTERPOLATION)) {
d_output << "(set-option :produce-interpolants true)" << std::endl;
}
}
void smt2_output_wrapper::add(expr::term_ref f, formula_class f_class) {
set_name_transformer nt(d_tm);
assertion a(d_total_assertions_count ++, f, f_class);
d_assertions.push_back(a);
bool needs_annotation = d_solver->supports(solver::UNSAT_CORE) || d_solver->supports(solver::INTERPOLATION);
d_output << "(assert ";
if (needs_annotation) {
d_output << "(! ";
}
d_output << f;
if (d_solver->supports(solver::UNSAT_CORE)) {
d_output << " :named a" << a.index;
}
if (d_solver->supports(solver::INTERPOLATION)) {
if (a.f_class == CLASS_B) {
d_output << " :interpolation-group B";
} else {
d_output << " :interpolation-group A";
}
}
if (needs_annotation) {
d_output << ")";
}
d_output << ")" << std::endl;
d_solver->add(f, f_class);
}
//=============================================================================
// Book track tuple
//=============================================================================
void TbTupleWriter::bookTracks() {
NTupleFilePtr file1(ntupleSvc(), "/NTUPLES/FILE1");
NTuplePtr nt(ntupleSvc(), "/NTUPLES/FILE1/TbTupleWriter/Tracks");
// Check if already booked.
if (nt) return;
nt = ntupleSvc()->book("/NTUPLES/FILE1/TbTupleWriter/Tracks",
CLID_ColumnWiseTuple, "nTuple of Tracks");
nt->addItem("TkID", m_TkID);
nt->addItem("TkTime", m_TkTime);
nt->addItem("TkHTime", m_TkHTime);
nt->addItem("TkNCl", m_TkNCl, 0, 10);
nt->addItem("TkX", m_TkX0);
nt->addItem("TkY", m_TkY0);
nt->addItem("TkTx", m_TkTx);
nt->addItem("TkTy", m_TkTy);
nt->addItem("TkChi2PerNdof", m_TkChi2ndof);
nt->addIndexedItem("TkClId", m_TkNCl, m_TkClId);
nt->addItem("TkEvt",m_TkEvt);
nt->addItem("TkNTg",m_TkNTg,0,(int)m_maxTriggers);
nt->addIndexedItem("TkTgId",m_TkNTg,m_TkTgId);
nt->addIndexedItem("TkTgPlane",m_TkNTg,m_TkTgPlane);
nt->addIndexedItem("TkXResidual",m_TkNCl, m_TkXResidual);
nt->addIndexedItem("TkYResidual",m_TkNCl, m_TkYResidual);
}
void smt2_output_wrapper::add_variable(expr::term_ref var, variable_class f_class) {
set_name_transformer nt(d_tm);
d_output << "(declare-fun " << var << " () " << d_tm.type_of(var) << ")" << std::endl;
solver::add_variable(var, f_class);
d_solver->add_variable(var, f_class);
}
void Try(int a)
{
if (d>2)
{
if (a==0)
{
if (kt(b[0]+b[1])==0 && kt(b[1]+b[2])==0)
{
for (int i=0;i<=2;i++) cout<<b[i]<<"+";
cout<<endl;
l[m++]=b[0]+b[1];
l[m++]=b[1]+b[2];
}
}
}
else
{
for (int i=2;i<=a;i++)
if (nt(i)==1)
{
b[d]=i;
d++;
Try(a-i);
d--;
}
}
}
void CppTree2Uml::parseTemplateDeclaration(TemplateDeclarationAST* ast)
{
TemplateParameterListAST* parmListAST = ast->templateParameterList();
if (parmListAST == NULL)
return;
QList<TemplateParameterAST*> parmList = parmListAST->templateParameterList();
for (int i = 0; i < parmList.size(); ++i) {
// The template is either a typeParameter or a typeValueParameter.
TemplateParameterAST* tmplParmNode = parmList.at(i);
TypeParameterAST* typeParmNode = tmplParmNode->typeParameter();
if (typeParmNode) {
NameAST* nameNode = typeParmNode->name();
if (nameNode) {
QString typeName = nameNode->unqualifiedName()->text();
Model_Utils::NameAndType nt(typeName, NULL);
m_templateParams.append(nt);
} else {
uError() << "nameNode is NULL";
}
}
ParameterDeclarationAST* valueNode = tmplParmNode->typeValueParameter();
if (valueNode) {
TypeSpecifierAST* typeSpec = valueNode->typeSpec();
if (typeSpec == NULL) {
uError() << "typeSpec is NULL";
continue;
}
QString typeName = typeSpec->name()->text();
UMLObject *t = Import_Utils::createUMLObject(UMLObject::ot_UMLObject, typeName,
m_currentNamespace[m_nsCnt]);
DeclaratorAST* declNode = valueNode->declarator();
NameAST* nameNode = declNode->declaratorId();
if (nameNode == NULL) {
uError() << "CppTree2Uml::parseTemplateDeclaration(value):"
<< " nameNode is NULL";
continue;
}
QString paramName = nameNode->unqualifiedName()->text();
Model_Utils::NameAndType nt(paramName, t);
m_templateParams.append(nt);
}
}
if (ast->declaration())
TreeParser::parseDeclaration(ast->declaration());
}
void smt2_output_wrapper::push() {
set_name_transformer nt(d_tm);
d_output << "(push 1)" << std::endl;
d_solver->push();
d_assertions_size.push_back(d_assertions.size());
}
std::ostream& FOBDD::put(std::ostream& output) const {
output << print(_kernel);
pushtab();
output << "" <<nt();
output << "FALSE BRANCH:";
pushtab();
output << "" <<nt();
output << print(_falsebranch);
poptab();
output << "" <<nt();
output << "TRUE BRANCH:";
pushtab();
output << "" <<nt();
output << print(_truebranch);
poptab();
poptab();
return output;
}
void dfs(vector< vector<Node> > & vv, vector<Node>& v, int n, int x) {
if(x >= n - 1 ) {
for(int i = 0; i < n; i++) {
if( isValid(v, x, i) ) {
vector<Node> vt(v);
Node nt(x, i);
vt.push_back(nt);
vv.push_back(vt);
}
}
return ;
}
for(int i = 0; i < n; i++) {
if( isValid(v, x, i) ) {
Node nt(x, i);
v.push_back(nt);
dfs(vv, v, n, x + 1);
v.pop_back();
}
}
}
void smt2_output_wrapper::pop() {
set_name_transformer nt(d_tm);
d_output << "(pop 1)" << std::endl;
d_solver->pop();
size_t size = d_assertions_size.back();
d_assertions_size.pop_back();
while (d_assertions.size() > size) {
d_assertions.pop_back();
}
}
void Templates::on_pushButton_New_clicked()
{
newTemplate nt(this);
nt.setTemplates(temp);
if (nt.exec() == QDialog::Accepted)
{
temp = nt.getTemplates();
tempOriginal << temp.back();
setTemplate(temp.back());
ui->pushButton_Delete->setEnabled(ui->comboBoxNew->count() != 0);
ui->pushButton_Save->setEnabled(ui->comboBoxNew->count() != 0);
}
}
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));
}
}
//=============================================================================
// Book trigger tuple
//=============================================================================
void TbTupleWriter::bookTriggers() {
NTupleFilePtr file1(ntupleSvc(), "/NTUPLES/FILE1");
NTuplePtr nt(ntupleSvc(), "/NTUPLES/FILE1/TbTupleWriter/Trigger");
// Check if already booked.
if (nt) return;
nt = ntupleSvc()->book("/NTUPLES/FILE1/TbTupleWriter/Trigger",
CLID_ColumnWiseTuple, "nTuple of Triggers");
nt->addItem("TgID", m_TgID);
nt->addItem("TgTime", m_TgTime);
nt->addItem("TgHTime", m_TgHTime);
nt->addItem("TgEvt", m_TgEvt);
nt->addItem("TgPlane", m_TgPlane);
nt->addItem("TgCounter",m_TgCounter);
}
int main()
{
NinjaTrap nt("naze");
FragTrap ft("filou");
ScavTrap st("saurien");
SuperTrap sut("Super Tramp");
testCommuns(ft, st, nt, sut);
testNinjaSpecials(nt);
testScavSpecials(st);
testFragSpecials(ft);
testNinjaSpecials(sut);
testFragSpecials(sut);
return 0;
}
static void
test_value_move_ctor ()
{
rw_info (0, __FILE__, __LINE__, "value move constructor");
#define INTEGER_CONSTANT 256
std::tuple<int> it1 (INTEGER_CONSTANT);
test (__LINE__, it1, INTEGER_CONSTANT);
const int c = std::rand ();
int i = c; // move semantics can alter source value
std::tuple<int> it2 (i); // temporary source value
test (__LINE__, it2, c);
const std::tuple<int> it3 (INTEGER_CONSTANT);
test (__LINE__, it3, INTEGER_CONSTANT);
i = c;
const std::tuple<int> it4 (i);
test (__LINE__, it4, c);
std::tuple<const int> ct1 (INTEGER_CONSTANT);
test (__LINE__, ct1, INTEGER_CONSTANT);
i = c;
std::tuple<const int> ct2 (i);
test (__LINE__, ct2, c);
// ill-formed for tuples with element types containing references
std::tuple<std::tuple<int> > nt (it1);
test (__LINE__, nt, it1);
std::tuple<long, const char*> pt (123456789L, "string");
test (__LINE__, pt, 123456789L, (const char*) "string");
const UserDefined src (c);
UserDefined tmp (src);
UserDefined::reset ();
std::tuple<UserDefined> ut (tmp);
UserDefined::expect.move_ctor = 1;
test (__LINE__, ut, src);
tmp = src; ++UserDefined::expect.copy_asgn;
std::tuple<bool, char, int, double, void*, UserDefined>
bt (true, 'a', INTEGER_CONSTANT, 3.14159, (void*) 0, tmp);
++UserDefined::expect.move_ctor;
test (__LINE__, bt,
true, 'a', INTEGER_CONSTANT, 3.14159, (void*) 0, src);
}
NTSequence::NTSequence(const std::string &name, const std::string &description,
const std::string &aSeqString,
bool sampleAmbiguities)
throw (ParseException)
: std::vector<Nucleotide>(aSeqString.length()),
name_(name),
description_(description)
{
for (unsigned i = 0; i < aSeqString.length(); ++i) {
Nucleotide nt(aSeqString[i]);
if (sampleAmbiguities)
nt.sampleAmbiguity();
(*this)[i] = nt;
}
}
void
NtEInfo::
print(jstream& os)
{
int num=0;
for(iterator iter=begin(); iter!=end(); iter++)
{
string rightPart=iter->first;
double rcount=iter->second;
Rule rule;
rule.left=nt();
rule.right=rightPart;
rule.prob=rcount/count();
rule.print(os);
}
}
//=============================================================================
// Book hit tuple
//=============================================================================
void TbTupleWriter::bookHits() {
NTupleFilePtr file1(ntupleSvc(), "/NTUPLES/FILE1");
NTuplePtr nt(ntupleSvc(), "/NTUPLES/FILE1/TbTupleWriter/Hits");
// Check if already booked.
if (nt) return;
nt = ntupleSvc()->book("/NTUPLES/FILE1/TbTupleWriter/Hits",
CLID_ColumnWiseTuple, "nTuple of Hits");
nt->addItem("hID", m_hID);
nt->addItem("hCol", m_hCol);
nt->addItem("hRow", m_hRow);
nt->addItem("hTime", m_hTime);
nt->addItem("hHTime", m_hHTime);
nt->addItem("hToT", m_hToT);
nt->addItem("hPlane", m_hPlane);
}
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());
}
}
static void static_compile(tool_options_t &opts)
{
netlist_tool_t nt("netlist");
nt.m_opts = &opts;
nt.init();
nt.log().verbose.set_enabled(false);
nt.log().warning.set_enabled(false);
nt.read_netlist(opts.opt_file(), opts.opt_name());
nt.solver()->create_solver_code(pout_strm);
nt.stop();
}
void tool_app_t::create_docheader()
{
netlist_tool_t nt(*this, "netlist");
nt.init();
nt.log().verbose.set_enabled(false);
nt.log().warning.set_enabled(false);
nt.setup().register_source(plib::make_unique_base<netlist::source_t,
netlist::source_proc_t>(nt.setup(), "dummy", &netlist_dummy));
nt.setup().include("dummy");
std::vector<pstring> devs;
for (auto &e : nt.setup().factory())
devs.push_back(e->name());
std::sort(devs.begin(), devs.end(), [&](pstring &a, pstring &b) { return a < b; });
pout("// license:GPL-2.0+\n");
pout("// copyright-holders:Couriersud\n");
pout("/* ----------------------------------------------------------------------------\n");
pout(" * Automatically created file. DO NOT MODIFY.\n");
pout(" * ---------------------------------------------------------------------------*/\n");
pout("/*!\n");
pout(" * \\page devices Devices\n");
pout(" *\n");
pout(" * Below is a list of all the devices currently known to the system ...\n");
pout(" *\n");
for (auto &s : devs)
pout(" * - \\subpage {1}\n", s);
pout(" *\n");
for (auto &e : nt.setup().factory())
{
pout("//! [{1} csynopsis]\n", e->name());
cmac(e.get());
pout("//! [{1} csynopsis]\n", e->name());
pout("//! [{1} synopsis]\n", e->name());
mac(e.get());
pout("//! [{1} synopsis]\n", e->name());
}
nt.stop();
}
int
NetCallback::NodeAssociation(Vector<pnl::CNodeType> *paNodeType,
bool isDiscrete, int size, int nodeState)
{
pnl::CNodeType nt(isDiscrete ? 1:0, size, pnl::EIDNodeState(nodeState));
for(int i = paNodeType->size(); --i >= 0;)
{
if((*paNodeType)[i] == nt)
{
return i;
}
}
paNodeType->push_back(nt);
return paNodeType->size() - 1;
}
void tool_app_t::create_header()
{
netlist_tool_t nt(*this, "netlist");
nt.init();
nt.log().verbose.set_enabled(false);
nt.log().warning.set_enabled(false);
nt.setup().register_source(plib::make_unique_base<netlist::source_t,
netlist::source_proc_t>(nt.setup(), "dummy", &netlist_dummy));
nt.setup().include("dummy");
pout("// license:GPL-2.0+\n");
pout("// copyright-holders:Couriersud\n");
pout("#ifndef NLD_DEVINC_H\n");
pout("#define NLD_DEVINC_H\n");
pout("\n");
pout("#include \"nl_setup.h\"\n");
pout("#ifndef __PLIB_PREPROCESSOR__\n");
pout("\n");
pout("/* ----------------------------------------------------------------------------\n");
pout(" * Netlist Macros\n");
pout(" * ---------------------------------------------------------------------------*/\n");
pout("\n");
pstring last_source("");
for (auto &e : nt.setup().factory())
{
if (last_source != e->sourcefile())
{
last_source = e->sourcefile();
pout("{1}\n", pstring("// ").rpad("-", 72));
pout("{1}{2}\n", pstring("// Source: "), e->sourcefile().replace_all("../", ""));
pout("{1}\n", pstring("// ").rpad("-", 72));
}
cmac(e.get());
}
pout("#endif // __PLIB_PREPROCESSOR__\n");
pout("#endif\n");
nt.stop();
}
expr::model::ref smt2_output_wrapper::get_model() const {
set_name_transformer nt(d_tm);
std::ofstream& out_nonconst = const_cast<smt2_output_wrapper*>(this)->d_output;
out_nonconst << "(get-value (";
std::set<expr::term_ref>::const_iterator it;
bool space = false;
for (it = d_A_variables.begin(); it != d_A_variables.end(); ++ it, space = true) {
if (space) { out_nonconst << " "; }
out_nonconst << *it << std::endl;
}
for (it = d_B_variables.begin(); it != d_B_variables.end(); ++ it, space = true) {
if (space) { out_nonconst << " "; }
out_nonconst << *it << std::endl;
}
out_nonconst << "))" << std::endl;
return d_solver->get_model();
}
void helper(int lastnum, char lastopt, int i, stack<int>& n, stack<char>& opt)
{
stack<int> nt(n);
stack<char> optt(opt);
int num = num_set[i];
optt.push(lastopt);
nt.push(lastnum);
if(len-1 == i)
{
while(!nt.empty())
{
int tmpn = nt.top();
nt.pop();
char tmpopt = optt.top();
optt.pop();
num = cal(tmpn,tmpopt,num);
}
res.push_back(num);
}
else
{
helper(num,opt_set[i],i+1,nt,optt);
while(!nt.empty())
{
int tmpn = nt.top();
nt.pop();
char tmpopt = optt.top();
optt.pop();
num = cal(tmpn,tmpopt,num);
helper(num,opt_set[i],i+1,nt,optt);
}
}
}
