Esempio n. 1
0
void soc::SocSystem_Ors::getTargetV(arr& v_i,real& y_prec,uint i,uint t){
  if(!t && vars(i)->targetType!=trajectoryTT){
    v_i    = vars(i)->v_target;
    y_prec = vars(i)->v_prec;
    return;
  }
  v_i    = vars(i)->v_trajectory[t];
  y_prec = vars(i)->v_prec_trajectory(t);
}
Esempio n. 2
0
void soc::SocSystem_Ors::getJtJ(arr& J_i,arr& tJ_i,uint i){
  //vars(i)->updateJacobian();
  if(!WS->Qlin.N){
    J_i=vars(i)->J;
    tJ_i=vars(i)->tJ;
  }else{
    J_i=vars(i)->J*WS->Qlin;
    transpose(tJ_i,J_i);
  }
}
Esempio n. 3
0
void soc::SocSystem_Ors::getTarget(arr& y_i,real& y_prec,uint i,uint t){
  if(!t && vars(i)->targetType!=trajectoryTT){
    TaskVariable *v=vars(i);
    v->updateChange(-1);
    y_i  = v->y+v->y_change;
    y_prec = vars(i)->y_prec;
    return;
  }
  y_i    = vars(i)->y_trajectory[t];
  y_prec = vars(i)->y_prec_trajectory(t);
}
 /***
  * @brief Implementation of observation DEVS function
  */
 std::unique_ptr<vv::Value> observation(
         const vd::ObservationEvent& event) const override
 {
     const std::string& port = event.getPortName();
     {
         Variables::const_iterator itf = vars().find(port);
         if (itf != vars().end()) {
             return value::Double::create(itf->second->getVal());
         }
     }
     return 0;
 }
 /**
  * @brief Output function that fills the value of state variables
  * @param time, time of the output
  * @param extEvtList, the list of external event
  */
 void outputVar(const vd::Time& /*time*/,
         vd::ExternalEventList& extEvtList) const
 {
     Variables::const_iterator itb = vars().begin();
     Variables::const_iterator ite = vars().end();
     for (; itb != ite; itb++) {
         const Variable& v = *itb->second;
         if (getModel().existOutputPort(itb->first)) {
             extEvtList.emplace_back(itb->first);
             value::Double& val = extEvtList.back().addDouble();
             val = v.getVal();
         }
     }
 }
Esempio n. 6
0
    void ResultSet::project (ProductionVector<const POS*> const * varsV) {
	std::set<const POS*> vars(varsV->begin(), varsV->end());

	/* List of vars to delete.
	 * This is cheaper than walking all the bindings in a row, but assumes
	 * that the row has no bindings which fail to appear in knownVars.
	 */
	std::set<const POS*> toDel;
	for (std::set<const POS*>::const_iterator knownVar = knownVars.begin();
	     knownVar != knownVars.end(); ++knownVar)
	    if (vars.find(*knownVar) == vars.end())
		toDel.insert(*knownVar);

	/* Delete those vars from each row, and from knowVars. */
	for (ResultSetIterator row = results.begin();
	     row != results.end(); ++row)
	    for (std::set<const POS*>::const_iterator var = toDel.begin();
		 var != toDel.end(); ++var)
		if ((*row)->find(*var) != (*row)->end())
		    (*row)->erase((*row)->find(*var));

	/* Delete those vars from knowVars. */
	for (std::set<const POS*>::const_iterator var = toDel.begin();
	     var != toDel.end(); ++var)
	    knownVars.erase(*var);

	selectOrder = *varsV;
	orderedSelect = true;

    }
Esempio n. 7
0
void test_vector() {
  std::vector<TT> vars(5);
  TT t;
  TT f;

  TT::variables(vars.begin(), vars.end(), t, f);

  TT a = vars[0];
  TT b = vars[1];

  assert((a & (b & ~a)) == f);
  assert((a & (~a)) == f);
  assert((a | (~a)) == t);
  assert((b & (~b)) == f);
  assert((b | (~b)) == t);
  assert(b.negCofactor(b) == f);
  assert(b.posCofactor(b) == t);
  assert(a.negCofactor(a) == f);
  assert(a.posCofactor(a) == t);

  TT c = a & b;
  assert(c.posCofactor(a) == b);

  TT c1 = a | b;
  assert(c1.negCofactor(a) == b);

  TT d = a & b & ~(vars[2] | vars[3]);
  TT e = d.posCofactor(a);
  
  assert(TT::firstVar(vars.begin(), vars.end(), e,e) == (vars.begin()+1));
}
Esempio n. 8
0
bool SaveLoad_v6::GameHandler::loadExtra(int slot, uint8 id,
		int16 dataVar, int32 size, int32 offset) {

	if (!_reader || (_reader->getSlot() != (uint32)slot))
		return false;

	SavePartMem mem(1);
	if (!_reader->readPart(2, &mem))
		return false;

	uint8 extraSaveNumber;
	if (!mem.writeInto(&extraSaveNumber, 0, 1))
		return false;

	if (extraSaveNumber != id)
		return false;

	uint32 varSize = SaveHandler::getVarSize(_vm);

	SavePartVars vars(_vm, varSize);
	if (!_reader->readPart(3, &vars))
		return false;

	if (!vars.writeInto(0, 0, varSize))
		return false;

	return true;
}
Esempio n. 9
0
void short_test() {
  std::vector<TT> vars(2);
  TT t;
  TT f;

  TT::variables(vars.begin(), vars.end(), t, f);

  TT a = vars[0];
  TT b = vars[1];

  assert((a & (~a)) == f);
  assert((a | (~a)) == t);
  assert((b & (~b)) == f);
  assert((b | (~b)) == t);
  assert(b.negCofactor(b) == f);
  assert(b.posCofactor(b) == t);
  assert(a.negCofactor(a) == f);
  assert(a.posCofactor(a) == t);

  TT c = a & b;
  assert(c.posCofactor(a) == b);

  TT c1 = a | b;
  assert(c1.negCofactor(a) == b);

  std::pair<TT,TT> p = c.cofactors(a);
  assert(p.second == b);
  assert(p.first == f);
}
Esempio n. 10
0
static Array HHVM_FUNCTION(xdebug_get_declared_vars) {
  if (RuntimeOption::RepoAuthoritative) {
    raise_error("xdebug_get_declared_vars unsupported in RepoAuthoritative "
      "mode");
  }

  // Grab the callee function
  VMRegAnchor _; // Ensure consistent state for vmfp
  auto func = g_context->getPrevFunc(vmfp());
  if (!func) {
    return Array::Create();
  }

  // Add each named local to the returned array. Note that since this function
  // is supposed to return all _declared_ variables in scope, which includes
  // variables that have been unset.
  auto const numNames = func->numNamedLocals();
  PackedArrayInit vars(numNames);
  for (Id i = 0; i < numNames; ++i) {
    assert(func->lookupVarId(func->localVarName(i)) == i);
    String varname(const_cast<StringData*>(func->localVarName(i)));
    // Skip the internal closure "0Closure" variable
    if (!s_closure_varname.equal(varname)) {
      vars.append(varname);
    }
  }
  return vars.toArray();
}
Esempio n. 11
0
bool SaveLoad_v6::GameHandler::saveExtra(int slot, uint8 id,
		int16 dataVar, int32 size, int32 offset) {

	if (!_writer || (_writer->getSlot() != (uint32)slot))
		return false;

	uint32 varSize = SaveHandler::getVarSize(_vm);

	SavePartMem  mem(1);
	SavePartVars vars(_vm, varSize);

	if (!mem.readFrom(&id, 0, 1))
		return false;
	if (!vars.readFrom(0, 0, varSize))
		return false;

	if (!_writer->writePart(2, &mem))
		return false;
	if (!_writer->writePart(3, &vars))
		return false;

	_hasExtra = true;

	return true;
}
Esempio n. 12
0
    // 
    // Hoist quantifier from rule (universal) or query (existential)
    // 
    unsigned rule_manager::hoist_quantifier(bool is_forall, expr_ref& fml, svector<symbol>* names) {   

        unsigned index = var_counter().get_next_var(fml);
        while (is_quantifier(fml) && (is_forall == to_quantifier(fml)->is_forall())) {
            quantifier* q = to_quantifier(fml);
            index += q->get_num_decls();
            if (names) {
                names->append(q->get_num_decls(), q->get_decl_names());
            }
            fml = q->get_expr();
        }
        if (!has_quantifiers(fml)) {
            return index;
        }
        app_ref_vector vars(m);
        quantifier_hoister qh(m);
        qh.pull_quantifier(is_forall, fml, vars);
        if (vars.empty()) {
            return index;
        }
        // replace vars by de-bruijn indices
        expr_substitution sub(m);
        for (unsigned i = 0; i < vars.size(); ++i) {
            app* v = vars[i].get();
            if (names) {
                names->push_back(v->get_decl()->get_name());
            }                
            sub.insert(v, m.mk_var(index++,m.get_sort(v)));
        }
        scoped_ptr<expr_replacer> rep = mk_default_expr_replacer(m); 
        rep->set_substitution(&sub);
        (*rep)(fml);
        return index;
    }
Esempio n. 13
0
SLP *edict2slp(EDICT *edict){
  uInt i;
  // vector<varpair> vars(edict->numRules - CHAR_SIZE + 1);
  vector<uInt_pair> vars(edict->numRules - CHAR_SIZE - 1);
  // vector<uInt_pair> vars(edict->numRules);
  string alphabet;
  cout << "read alphabet" << endl;
  for(i = 0; i <= CHAR_SIZE; i++){
    alphabet.push_back((char)i);
  }
  cout << "read rules" << endl;
  for(i = CHAR_SIZE + 1; i < edict->numRules; i++){
    if(edict->rule[i].left > i
       || edict->rule[i].right > i
       || edict->rule[i].left  >= edict->numRules
       || edict->rule[i].left  >= edict->numRules
      ){
      cout << "i=" << i << " left=" << edict->rule[i].left << " right=" << edict->rule[i].left << endl;
    }
    uInt_pair v;
    vars[i - (CHAR_SIZE + 1)].first = (uInt)(edict->rule[i].left);
    vars[i - (CHAR_SIZE + 1)].second = (uInt)(edict->rule[i].right);
  }
  cout << "create SLP" << endl;
  return new SLP(alphabet, vars);
}
Esempio n. 14
0
    Z3_ast Z3_API Z3_qe_model_project (Z3_context c,
                                       Z3_model m,
                                       unsigned num_bounds,
                                       Z3_app const bound[],
                                       Z3_ast body)
    {
        Z3_TRY;
        LOG_Z3_qe_model_project (c, m, num_bounds, bound, body);
        RESET_ERROR_CODE();
      
        app_ref_vector vars(mk_c(c)->m ());
        if (!to_apps(num_bounds, bound, vars)) {
            SET_ERROR_CODE (Z3_INVALID_ARG);
            RETURN_Z3(0);
        }

        expr_ref result (mk_c(c)->m ());
        result = to_expr (body);
        model_ref model (to_model_ref (m));
        spacer::qe_project (mk_c(c)->m (), vars, result, model);
        mk_c(c)->save_ast_trail (result.get ());

        return of_expr (result.get ());
        Z3_CATCH_RETURN(0);
    }
Esempio n. 15
0
void variable_mode_controller::show_var(ttree_view_node& node)
{
	twidget* w = node.find("name", false);
	if(tlabel* label = dynamic_cast<tlabel*>(w)) {
		model().set_data(vars()[label->label()]);
	}
}
JBoolean
GLFitDescription::Create
	(
	istream& 			is,
	GLFitDescription** 	fd
	)
{
	JFileVersion version;
	is >> version;
	if (version > kCurrentSetupVersion)
		{
		return kJFalse;
		}
		
	int type;
	is >> type;
	JString form;
	is >> form;
	JString name;
	is >> name;
	JSize count;
	is >> count;
	JPtrArray<JString> vars(JPtrArrayT::kDeleteAll);
	for (JIndex i = 1; i <= count; i++)
		{
		JString* var = new JString();
		assert(var != NULL);
		is >> *var;
		vars.Append(var);
		}
	
	if (type == kPolynomial)
		{
		GLPolyFitDescription* pfd	= new GLPolyFitDescription(is);
		assert(pfd != NULL);
		*fd	= pfd;
		}
	else if (type == kNonLinear)
		{
		GLNonLinearFitDescription* nfd	= new GLNonLinearFitDescription(is);
		assert(nfd != NULL);
		*fd	= nfd;
		for (JIndex i = 1; i <= count; i++)
			{
			(*fd)->itsVarList->AddVariable(*(vars.NthElement(i)), 0);
			}
		(*fd)->SetParameterCount(count);		
		}
	else
		{
		return kJFalse;
		}

	vars.DeleteAll();
	(*fd)->itsFnName	= name;
	(*fd)->itsFnForm	= form;
		
	return kJTrue;
}
Esempio n. 17
0
    void Solver::setState(const Eigen::VectorXd& x) {
        int nVar = mProb->getNumVariables();
        std::vector<Var *>& vars(mProb->vars());

        for (int i = 0; i < nVar; i++) {
            vars[i]->mVal = x(i);
        }
    }
Esempio n. 18
0
void plotPull(string ptMin, string ptMax){

  TFile* file_in = new TFile(("pullOutFile_pt"+ptMin+"_"+ptMax+".root").c_str(), "READ");
  TTree* tree = (TTree*)file_in->Get("tree_toys");

  vector<string> vars(15);
  
  vars[0]  = "CBC_mean";
  vars[1]  = "CBC_sigma";
  vars[2]  = "CBC_alphaC";
  vars[3]  = "CBC_alphaCB";
  vars[4]  = "CBC_n";
  vars[5]  = "cbmean";
  vars[6]  = "cbsigma";
  vars[7]  = "cbalpha_s";
  vars[8]  = "cbn_s";
  vars[9]  = "frac_s";
  vars[10] = "gaussmean";
  vars[11] = "gausssigma";
  vars[12] = "frac_scut";
  vars[13] = "N_scut";
  vars[14] = "N_sig";

  vector<TH1F*> histos(15);
  for(int i=0; i<histos.size(); i++){
    histos[i] = new TH1F(("h_"+vars[i]).c_str(), ("h_"+vars[i]).c_str(), 500, -5., 5.);
  }

  vector<TH1F*> histos_err(15);
  for(int i=0; i<histos_err.size(); i++){
    histos_err[i] = new TH1F(("h_err_"+vars[i]).c_str(), ("h_err_"+vars[i]).c_str(), 100, 0., 1.);
  }

  TCanvas c;

  gStyle->SetOptFit(111111);
  for(int i=0; i<vars.size(); i++){
    tree->Draw(("(val_"+vars[i]+" - realVal_"+vars[i]+")/err_"+vars[i]+">>h(200, -5, 5").c_str());
    histos[i] = (TH1F*)((TH1F*)gDirectory->Get("h"))->Clone(histos[i]->GetName());
    histos[i]->Fit("gaus", "LL");
    histos[i]->Draw();
    c.SaveAs(("pull_"+vars[i]+"_pt"+ptMin+"_"+ptMax+".root").c_str());
    c.SaveAs(("pull_"+vars[i]+"_pt"+ptMin+"_"+ptMax+".png").c_str());
    c.SaveAs(("pull_"+vars[i]+"_pt"+ptMin+"_"+ptMax+".pdf").c_str());

    tree->Draw(("err_"+vars[i]+"/val_"+vars[i]+">>h()").c_str());
    histos_err[i] = (TH1F*)((TH1F*)gDirectory->Get("h"))->Clone(histos_err[i]->GetName());
    histos_err[i]->Draw();
    c.SaveAs(("err_"+vars[i]+"_pt"+ptMin+"_"+ptMax+".root").c_str());
    c.SaveAs(("err_"+vars[i]+"_pt"+ptMin+"_"+ptMax+".png").c_str());
    c.SaveAs(("err_"+vars[i]+"_pt"+ptMin+"_"+ptMax+".pdf").c_str());

    
  }
  

}
Esempio n. 19
0
void InspectionCompressorTab::init(const QVariantMap &var_values)
{
    Variables vars(QSqlDatabase(), Variable::Compressor);
    vars.initEditDialogueWidgets(this, var_values);

    QGridLayout *layout = new QGridLayout(this);

    EditInspectionDialogueLayout(&md_inputwidgets, &md_groups, layout).layout();
}
Esempio n. 20
0
void loginfrm::loadsysvars()
{
	QString qstr = "SELECT var, value FROM maincfg WHERE `var` = 'docfolder' OR `var` = 'templatefolder' ORDER BY var ASC;";
	QSqlQuery vars(qstr);
	vars.next();
	docfolder = vars.value(1).toString();
	vars.next();
	templatefolder = vars.value(1).toString();
}
 PyObject * PyOCIO_AllocationTransform_getVars(PyObject * self)
 {
     OCIO_PYTRY_ENTER()
     ConstAllocationTransformRcPtr transform = GetConstAllocationTransform(self);
     std::vector<float> vars(transform->getNumVars());
     if(!vars.empty()) transform->getVars(&vars[0]);
     return CreatePyListFromFloatVector(vars);
     OCIO_PYTRY_EXIT(NULL)
 }
Esempio n. 22
0
void EBPoissonOp::
prolongIncrement(LevelData<EBCellFAB>&       a_phiThisLevel,
                 const LevelData<EBCellFAB>& a_correctCoar)
{
  CH_TIME("EBPoissonOp::prolongIncrement");
  Interval vars(0, 0);
  CH_assert(m_hasMGObjects);
  m_ebInterpMG.pwcInterp(a_phiThisLevel, a_correctCoar, vars);
}
Esempio n. 23
0
void QuaggaAdapter::executeCommand(int argc, char* argv[])
{
  std::vector<std::string> vars(argv, argv+argc);
  // concatenate vars
  std::string command = "";
  std::for_each(vars.begin(), vars.end(), [&command](std::string & s){
    command.append(s).append(" ");
  });
  pipeToQuaggaShell(command);
}
Esempio n. 24
0
    Eigen::VectorXd Solver::getState() {
        int nVar = mProb->getNumVariables();
        std::vector<Var *>& vars(mProb->vars());

        VectorXd x(nVar);
        for (int i = 0; i < nVar; i++) {
            x(i) = vars[i]->mVal;
        }
        return x;
    }
Esempio n. 25
0
void SessionListWidget::parseQstat(QString const& qstat)
{
   QStringList lines = qstat.split('\n');

   JobDefinition *job = NULL;
   QMap<QString, QString> jobSpec, jobVars;

   QRegExp rxJobId("[0-9]+\\.pbs01");
   QRegExp rxKey("[A-Za-z_\\.]+");
   QString key(""), value("");
   for(QStringList::const_iterator line = lines.begin();
       line != lines.end();
       line++)
   {
      if(line->isEmpty()) { /* empty */ }
      else if(line->startsWith("Job Id:")) {
         if(job != NULL) {
            job->update(jobSpec);
            sessions.append(*job);
            delete job;
            job = NULL;
            jobSpec.clear();
            jobVars.clear();
         }
         rxJobId.indexIn(*line);
         job = new JobDefinition(rxJobId.cap());
      }
      else if(line->startsWith("    ")) {  /* keys start with 4 spaces */
         if(key == "Variable_List") {
            QStringList vars(jobSpec[key].split(","));
            for(QStringList::const_iterator i = vars.begin();
                i != vars.end(); 
                i++)
            {
               int eq = i->indexOf('=');
               jobVars.insert(i->left(eq), i->mid(eq + 1));
            }
         }
         rxKey.indexIn(*line);
         key = rxKey.cap(0);
         value = line->mid(line->indexOf('=') + 2);
         jobSpec.insert(key, value);
      }
      else if(line->at(0) == '\t') {
         /* append to the previous key */
         jobSpec[key].append(line->mid(1));
      }
   }
   if(job) {
      job->update(jobSpec);
      sessions.append(*job);
   }

   qDebug() << sessions;
}
Esempio n. 26
0
void test2() {
    ast_manager m;
    reg_decl_plugins(m);
    bv_util bv(m);
    datatype_util dtutil(m);
    params_ref p;

    datatype_decl_plugin & dt = *(static_cast<datatype_decl_plugin*>(m.get_plugin(m.get_family_id("datatype"))));
    sort_ref_vector new_sorts(m);
    constructor_decl* R = mk_constructor_decl(symbol("R"), symbol("is-R"), 0, nullptr);
    constructor_decl* G = mk_constructor_decl(symbol("G"), symbol("is-G"), 0, nullptr);
    constructor_decl* B = mk_constructor_decl(symbol("B"), symbol("is-B"), 0, nullptr);
    constructor_decl* constrs[3] = { R, G, B };
    datatype_decl * enum_sort = mk_datatype_decl(dtutil, symbol("RGB"), 0, nullptr, 3, constrs);
    VERIFY(dt.mk_datatypes(1, &enum_sort, 0, nullptr, new_sorts));
    sort* rgb = new_sorts[0].get();

    expr_ref x = mk_const(m, "x", rgb), y = mk_const(m, "y", rgb), z = mk_const(m, "z", rgb);
    ptr_vector<func_decl> const& enums = *dtutil.get_datatype_constructors(rgb);
    expr_ref r = expr_ref(m.mk_const(enums[0]), m);
    expr_ref g = expr_ref(m.mk_const(enums[1]), m);
    expr_ref b = expr_ref(m.mk_const(enums[2]), m);

    ref<solver> fd_solver = mk_fd_solver(m, p);
    fd_solver->assert_expr(m.mk_not(m.mk_eq(x, r)));
    fd_solver->assert_expr(m.mk_not(m.mk_eq(x, b)));

    expr_ref_vector asms(m), vars(m), conseq(m);
    vars.push_back(x);
    vars.push_back(y);

    VERIFY(l_true == fd_solver->get_consequences(asms, vars, conseq));
    std::cout << conseq << "\n";
    conseq.reset();

    fd_solver->push();
    fd_solver->assert_expr(m.mk_not(m.mk_eq(x, g)));
    VERIFY(l_false == fd_solver->check_sat(0,nullptr));
    fd_solver->pop(1);

    VERIFY(l_true == fd_solver->get_consequences(asms, vars, conseq));

    std::cout << conseq << "\n";
    conseq.reset();

    model_ref mr;
    fd_solver->get_model(mr);
    model_smt2_pp(std::cout << "model:\n", m, *mr.get(), 0);

    VERIFY(l_true == fd_solver->check_sat(0,nullptr));
    fd_solver->get_model(mr);
    ENSURE(mr.get());
    model_smt2_pp(std::cout, m, *mr.get(), 0);

}
Esempio n. 27
0
void ASTAnalyzer::printScopeDeclarations (Scope* scope) {
    Scope::FunctionIterator fuctions(scope);
    while (fuctions.hasNext()) {
        fuctions.next()->node()->visit(this);
    }
    Scope::VarIterator vars(scope);
    while (vars.hasNext()) {
        AstVar* var = vars.next();
        output << typeToName(var->type()) << " " << var->name() << ";\n";
    }
}
Esempio n. 28
0
void variable_mode_controller::show_array(tree_view_node& node)
{
	widget* w = node.find("name", false);
	if(label* lbl = dynamic_cast<label*>(w)) {
		const std::string& var = lbl->get_label();
		size_t n_start = var.find_last_of('[') + 1;
		size_t n_len = var.size() - n_start - 1;
		int n = std::stoi(var.substr(n_start, n_len));
		model().set_data(config_to_string(vars().child(var.substr(1, n_start - 3), n)));
	}
}
Esempio n. 29
0
void CPLEXSolver::add_in_constraint(LinearConstraint *con, double coef){
    DBG("Creating a Gurobi representation of a constriant %s\n", "");
    IloNumArray weights(*env, (IloInt)con->_coefficients.size());
    IloNumVarArray vars(*env, (IloInt)con->_variables.size());
    
    for(unsigned int i = 0; i < con->_variables.size(); ++i){
        DBG("\tAdding variable to CPLEX\n%s", "");
        IloNumVar var_ptr;
        
        if(con->_variables[i]->_var == NULL){
            
            IloNumVar::Type type;
        
            if(con->_variables[i]->_continuous) type = IloNumVar::Float;
            // else if(con->_lower == 0 && con->_upper == 1) type = IloNumVar::Bool;
            else type = IloNumVar::Int;

            var_ptr = IloNumVar(getEnv(),
                                con->_variables[i]->_lower, // LB
                                con->_variables[i]->_upper, // UB
                                type);

            int *var_id = new int;
            *var_id = variables->getSize();
            variables->add(var_ptr);
            con->_variables[i]->_var = (void*) var_id;
            
            DBG("Created new variable with id %d. type:%c lb:%f ub:%f coef:%f\n", *var_id, type, con->_variables[i]->_lower, con->_variables[i]->_upper, coef);
        } else {
            var_ptr = (*variables)[*(int*)(con->_variables[i]->_var)];
        }

        vars[i] = (*variables)[*(int*)(con->_variables[i]->_var)];
        weights[i] = con->_coefficients[i];
    }

    IloNumExprArg lin_expr = IloScalProd(weights, vars);

    if(coef < -0.1){
        model->add(IloMinimize(*env, lin_expr));
    } else if(coef > 0.1){
        model->add(IloMaximize(*env, lin_expr));
    } else {
        if(con->_lhs > -INFINITY && con->_rhs < INFINITY){
            if(con->_lhs == con->_rhs) {
                model->add(lin_expr == con->_lhs);
            } else {
                model->add(IloRange(*env, con->_lhs, lin_expr, con->_rhs));
            }
        } else if(con->_lhs > -INFINITY) model->add(lin_expr >= con->_lhs);
        else if(con->_rhs < INFINITY) model->add(lin_expr <= con->_rhs);
    }
}
Esempio n. 30
0
static void test2(char const *ex) {
    smt_params params;
    params.m_model = true;
    ast_manager m;
    reg_decl_plugins(m);
    arith_util a(m);
    expr_ref fml = parse_fml(m, ex);
    app_ref_vector vars(m);
    expr_ref_vector lits(m);
    vars.push_back(m.mk_const(symbol("x"), a.mk_real()));
    vars.push_back(m.mk_const(symbol("y"), a.mk_real()));
    vars.push_back(m.mk_const(symbol("z"), a.mk_real()));
    flatten_and(fml, lits);

    smt::context ctx(m, params);
    ctx.push();
    ctx.assert_expr(fml);
    lbool result = ctx.check();
    VERIFY(result == l_true);
    ref<model> md;
    ctx.get_model(md);  
    ctx.pop(1);
    
    std::cout << mk_pp(fml, m) << "\n";

    expr_ref pr1(m), pr2(m), fml2(m);
    expr_ref_vector bound(m);
    ptr_vector<sort> sorts;
    svector<symbol> names;
    for (unsigned i = 0; i < vars.size(); ++i) {
        bound.push_back(vars[i].get());
        names.push_back(vars[i]->get_decl()->get_name());
        sorts.push_back(m.get_sort(vars[i].get()));
    }
    expr_abstract(m, 0, bound.size(), bound.c_ptr(), fml, fml2);
    fml2 = m.mk_exists(bound.size(), sorts.c_ptr(), names.c_ptr(), fml2);
    qe::expr_quant_elim qe(m, params);
    for (unsigned i = 0; i < vars.size(); ++i) {
        VERIFY(qe::arith_project(*md, vars[i].get(), lits));
    }
    pr1 = mk_and(lits);
    qe(m.mk_true(), fml2, pr2);
    std::cout << mk_pp(pr1, m) << "\n";
    std::cout << mk_pp(pr2, m) << "\n";

    expr_ref npr2(m);
    npr2 = m.mk_not(pr2);
    ctx.push();
    ctx.assert_expr(pr1);
    ctx.assert_expr(npr2);
    VERIFY(l_false == ctx.check());
    ctx.pop(1);       
}