t_l *listtr(t_l **file, char *str, char *path) { t_arg stmp; stmp.file = (*file); stmp.path = listadd(str); /* ft_putstr("\n list tr ------ "); ft_putstr(path); ft_putstr(" list tr ------ \n"); */ stmp.npath = getpath(path, str); while (stmp.file != NULL) { stmp.lpath = getpath(path, stmp.file->str); if (stat(stmp.npath, &stmp.fs) < 0 || stat(stmp.lpath, &stmp.sf) < 0) return (0); if (stmp.fs.st_mtime < stmp.sf.st_mtime) return (cond1(&stmp, file)); if (stmp.file->next == NULL) { stmp.file->next = stmp.path; stmp.path->back = stmp.file; return (freeret(&stmp.lpath, &stmp.npath, *(file))); } ft_memdel((void **)&stmp.lpath); stmp.file = stmp.file->next; } return ((*file)); }
bool Foam::functionEntries::ifeqEntry::execute ( DynamicList<filePos>& stack, dictionary& parentDict, Istream& is ) { const label nNested = stack.size(); stack.append(filePos(is.name(), is.lineNumber())); // Read first token and expand any string token cond1(is); cond1 = expand(parentDict, cond1); // Read second token and expand any string token cond2(is); cond2 = expand(parentDict, cond2); const bool equal = equalToken(cond1, cond2); // Info<< "Using #" << typeName << " " << cond1 // << " == " << cond2 // << " at line " << stack.last().second() // << " in file " << stack.last().first() << endl; bool ok = ifeqEntry::execute(equal, stack, parentDict, is); if (stack.size() != nNested) { FatalIOErrorInFunction(parentDict) << "Did not find matching #endif for condition starting" << " at line " << stack.last().second() << " in file " << stack.last().first() << exit(FatalIOError); } return ok; }
void approx1(double w[], double x[], double r[][M], int m, int a[], double p[], double pp[][M], double *rec, int *idet) { double pra,rec2; double lb[8],ub[8],eps,bound,s[22]; int ii,a1,a2,idt,ifault,m1,inf[8]; void mulnor(double [], double [], double [], double, int, int [], double *, double *, int *); double cond1(int, int [], double [], double [][M], int *); /* approx , biv prob and product of cond prob*/ a1=a[1]; a2=a[2]; m1=2; inf[0]=2; inf[1]=2; eps=1.e-6; lb[0]=w[a1]; lb[1]=w[a2]; ub[0]=x[a1]; ub[1]=x[a2]; s[0]=r[a1][a2]; mulnor(ub,lb,s,eps,m1,inf,&rec2,&bound,&ifault); if(ifault!=0) printf("error in mulnor %d\n", ifault); *idet=1; for(ii=3;ii<=m;ii++) { pra=cond1(ii,a,p,pp,&idt); rec2*=pra; if(idt==0) *idet=0; } *rec=rec2; }
/// add axioms corresponding to the String.compareTo java function /// \par parameters: function application with two string arguments /// \return a integer expression exprt string_constraint_generatort::add_axioms_for_compare_to( const function_application_exprt &f) { string_exprt s1=add_axioms_for_string_expr(args(f, 2)[0]); string_exprt s2=add_axioms_for_string_expr(args(f, 2)[1]); const typet &return_type=f.type(); symbol_exprt res=fresh_symbol("compare_to", return_type); typet index_type=s1.length().type(); // In the lexicographic comparison, x is the first point where the two // strings differ. // We add axioms: // a1 : res==0 => |s1|=|s2| // a2 : forall i<|s1|. s1[i]==s2[i] // a3 : exists x. // res!=0 ==> x> 0 && // ((|s1| <= |s2| &&x<|s1|) || (|s1| >= |s2| &&x<|s2|) // &&res=s1[x]-s2[x] ) // || cond2: // (|s1|<|s2| &&x=|s1|) || (|s1| > |s2| &&x=|s2|) &&res=|s1|-|s2|) // a4 : forall i<x. res!=0 => s1[i]=s2[i] assert(return_type.id()==ID_signedbv); equal_exprt res_null=equal_exprt(res, from_integer(0, return_type)); implies_exprt a1(res_null, s1.axiom_for_has_same_length_as(s2)); axioms.push_back(a1); symbol_exprt i=fresh_univ_index("QA_compare_to", index_type); string_constraintt a2(i, s1.length(), res_null, equal_exprt(s1[i], s2[i])); axioms.push_back(a2); symbol_exprt x=fresh_exist_index("index_compare_to", index_type); equal_exprt ret_char_diff( res, minus_exprt( typecast_exprt(s1[x], return_type), typecast_exprt(s2[x], return_type))); equal_exprt ret_length_diff( res, minus_exprt( typecast_exprt(s1.length(), return_type), typecast_exprt(s2.length(), return_type))); or_exprt guard1( and_exprt(s1.axiom_for_is_shorter_than(s2), s1.axiom_for_is_strictly_longer_than(x)), and_exprt(s1.axiom_for_is_longer_than(s2), s2.axiom_for_is_strictly_longer_than(x))); and_exprt cond1(ret_char_diff, guard1); or_exprt guard2( and_exprt(s2.axiom_for_is_strictly_longer_than(s1), s1.axiom_for_has_length(x)), and_exprt(s1.axiom_for_is_strictly_longer_than(s2), s2.axiom_for_has_length(x))); and_exprt cond2(ret_length_diff, guard2); implies_exprt a3( not_exprt(res_null), and_exprt( binary_relation_exprt(x, ID_ge, from_integer(0, return_type)), or_exprt(cond1, cond2))); axioms.push_back(a3); string_constraintt a4(i, x, not_exprt(res_null), equal_exprt(s1[i], s2[i])); axioms.push_back(a4); return res; }
static void test_interval_relation() { smt_params params; ast_manager ast_m; register_engine re; context ctx(ast_m, re, params); arith_util autil(ast_m); relation_manager & m = ctx.get_rel_context()->get_rmanager(); m.register_plugin(alloc(interval_relation_plugin, m)); interval_relation_plugin& ip = dynamic_cast<interval_relation_plugin&>(*m.get_relation_plugin(symbol("interval_relation"))); SASSERT(&ip); relation_signature sig; sort* int_sort = autil.mk_int(); sig.push_back(int_sort); sig.push_back(int_sort); sig.push_back(int_sort); sig.push_back(int_sort); interval_relation& i1 = dynamic_cast<interval_relation&>(*ip.mk_empty(sig)); interval_relation& i2 = dynamic_cast<interval_relation&>(*ip.mk_full(0, sig)); i1.display(std::cout); i2.display(std::cout); SASSERT(i1.empty()); SASSERT(!i2.empty()); app_ref cond1(ast_m), cond2(ast_m), cond3(ast_m); app_ref cond4(ast_m), cond5(ast_m), cond6(ast_m); app_ref num1(ast_m); cond1 = autil.mk_le(ast_m.mk_var(0, int_sort), autil.mk_numeral(rational(0), true)); cond2 = autil.mk_le(ast_m.mk_var(1, int_sort), autil.mk_numeral(rational(1), true)); cond3 = autil.mk_le(ast_m.mk_var(2, int_sort), autil.mk_numeral(rational(2), true)); cond4 = autil.mk_ge(ast_m.mk_var(0, int_sort), autil.mk_numeral(rational(0), true)); cond5 = autil.mk_ge(ast_m.mk_var(1, int_sort), autil.mk_numeral(rational(0), true)); cond6 = autil.mk_ge(ast_m.mk_var(2, int_sort), autil.mk_numeral(rational(5), true)); num1 = autil.mk_numeral(rational(4), true); i2.filter_interpreted(cond1); i2.display(std::cout); // x0 <= 0 unsigned cols1[2] = { 1, 2}; unsigned cols2[2] = { 2, 3}; relation_join_fn* join1 = ip.mk_join_fn(i1, i2, 2, cols1, cols2); relation_transformer_fn* proj1 = ip.mk_project_fn(i1, 2, cols2); relation_transformer_fn* ren1 = ip.mk_rename_fn(i1, 2, cols2); relation_union_fn* union1 = ip.mk_union_fn(i1, i2, &i1); relation_mutator_fn* filterId1 = ip.mk_filter_identical_fn(i1, 2, cols1); relation_mutator_fn* filterEq1 = ip.mk_filter_equal_fn(i1, num1, 2); relation_mutator_fn* filterCond1 = ip.mk_filter_interpreted_fn(i1, cond2); relation_base* i3 = (*join1)(i2, i2); i3->display(std::cout); relation_transformer_fn* proj2 = ip.mk_project_fn(*i3, 2, cols2); (*filterEq1)(i2); i2.display(std::cout); // x0 <= 0 // x2 = 4 (*filterId1)(i2); i2.display(std::cout); // x0 <= 0 // x1 = x2 = 4 relation_fact fact1(ast_m); fact1.push_back(autil.mk_numeral(rational(0), true)); fact1.push_back(autil.mk_numeral(rational(4), true)); fact1.push_back(autil.mk_numeral(rational(4), true)); fact1.push_back(autil.mk_numeral(rational(5), true)); SASSERT(i2.contains_fact(fact1)); fact1[0] = autil.mk_numeral(rational(-1), true); SASSERT(i2.contains_fact(fact1)); fact1[0] = autil.mk_numeral(rational(1), true); SASSERT(!i2.contains_fact(fact1)); relation_base* i5 = (*ren1)(i2); i2.display(std::cout << "Orig\n"); i5->display(std::cout << "renamed 2 |-> 3 |-> 2\n"); (*filterCond1)(i2); i2.display(std::cout); // empty SASSERT(i2.empty()); relation_base* i4 = (*proj2)(*i3); i4->display(std::cout); i1.deallocate(); i2.deallocate(); i3->deallocate(); i4->deallocate(); i5->deallocate(); dealloc(join1); dealloc(proj1); dealloc(ren1); dealloc(union1); dealloc(filterId1); dealloc(filterEq1); dealloc(filterCond1); }
static void test_bound_relation() { std::cout << "bound relation\n"; smt_params params; ast_manager ast_m; register_engine re; context ctx(ast_m, re, params); arith_util autil(ast_m); relation_manager & m = ctx.get_rel_context()->get_rmanager(); m.register_plugin(alloc(bound_relation_plugin, m)); bound_relation_plugin& br = dynamic_cast<bound_relation_plugin&>(*m.get_relation_plugin(symbol("bound_relation"))); SASSERT(&br); relation_signature sig; sort* int_sort = autil.mk_int(); sig.push_back(int_sort); sig.push_back(int_sort); sig.push_back(int_sort); sig.push_back(int_sort); bound_relation& i1 = dynamic_cast<bound_relation&>(*br.mk_empty(sig)); bound_relation& i2 = dynamic_cast<bound_relation&>(*br.mk_full(0, sig)); i1.display(std::cout << "empty:\n"); i2.display(std::cout << "full:\n"); SASSERT(i1.empty()); SASSERT(!i2.empty()); app_ref cond1(ast_m), cond2(ast_m), cond3(ast_m); app_ref cond4(ast_m), cond5(ast_m), cond6(ast_m); app_ref num1(ast_m); cond1 = autil.mk_lt(ast_m.mk_var(0, int_sort), autil.mk_numeral(rational(0), true)); cond2 = autil.mk_lt(ast_m.mk_var(1, int_sort), autil.mk_numeral(rational(1), true)); cond3 = autil.mk_lt(ast_m.mk_var(2, int_sort), ast_m.mk_var(3, int_sort)); cond4 = autil.mk_ge(ast_m.mk_var(0, int_sort), autil.mk_numeral(rational(0), true)); cond5 = autil.mk_ge(ast_m.mk_var(1, int_sort), autil.mk_numeral(rational(0), true)); cond6 = autil.mk_ge(ast_m.mk_var(2, int_sort), autil.mk_numeral(rational(5), true)); app_ref lt_x0x1(ast_m), lt_x1x2(ast_m), lt_x0x3(ast_m), lt_x0x2(ast_m); lt_x0x1 = autil.mk_lt(ast_m.mk_var(0, int_sort), ast_m.mk_var(1, int_sort)); lt_x1x2 = autil.mk_lt(ast_m.mk_var(1, int_sort), ast_m.mk_var(2, int_sort)); lt_x0x2 = autil.mk_lt(ast_m.mk_var(0, int_sort), ast_m.mk_var(2, int_sort)); lt_x0x3 = autil.mk_lt(ast_m.mk_var(0, int_sort), ast_m.mk_var(3, int_sort)); num1 = autil.mk_numeral(rational(4), true); unsigned cols1[2] = { 1, 2}; unsigned cols2[2] = { 2, 3}; unsigned cols3[3] = { 0, 2, 3 }; relation_join_fn* join1 = br.mk_join_fn(i1, i2, 2, cols1, cols2); relation_transformer_fn* proj1 = br.mk_project_fn(i1, 2, cols2); relation_transformer_fn* ren1 = br.mk_rename_fn(i1, 3, cols3); relation_union_fn* union1 = br.mk_union_fn(i1, i2, &i1); relation_mutator_fn* filterId1 = br.mk_filter_identical_fn(i1, 2, cols1); relation_mutator_fn* filterEq1 = br.mk_filter_equal_fn(i1, num1, 2); relation_mutator_fn* filterCond1 = br.mk_filter_interpreted_fn(i1, cond3); relation_base* i3 = (*join1)(i2, i2); i3->display(std::cout); relation_transformer_fn* proj2 = br.mk_project_fn(*i3, 2, cols2); (*filterEq1)(i2); i2.display(std::cout << "no-op still full\n"); // no-op (*filterCond1)(i2); i2.display(std::cout << "x2 < x3\n"); // x2 < x3 (*filterId1)(i2); i2.display(std::cout << "id\n"); // x1 = x2 < x3 relation_fact fact1(ast_m); i2.display(std::cout << "Orig\n"); std::cout << "renamed "; for (unsigned i = 0; i < 3; ++i) { std::cout << cols3[i] << " "; } std::cout << "\n"; relation_base* i5 = (*ren1)(i2); i5->display(std::cout); //SASSERT(i2.empty()); relation_base* i4 = (*proj2)(*i3); i4->display(std::cout); // test that equivalence classes are expanded. // { x1 = x3, x0 < x1 x1 < x2} u { x2 = x3, x0 < x3 } = { x0 < x3 } { relation_base* b1 = br.mk_full(0, sig); relation_base* b2 = br.mk_full(0, sig); unsigned x1x3[2] = { 1, 3 }; unsigned x2x3[2] = { 2, 3 }; scoped_ptr<relation_mutator_fn> id1 = br.mk_filter_identical_fn(*b1, 2, x1x3); scoped_ptr<relation_mutator_fn> ltx0x1 = br.mk_filter_interpreted_fn(*b1, lt_x0x1); scoped_ptr<relation_mutator_fn> ltx1x2 = br.mk_filter_interpreted_fn(*b1, lt_x1x2); scoped_ptr<relation_mutator_fn> ltx0x3 = br.mk_filter_interpreted_fn(*b2, lt_x0x3); scoped_ptr<relation_mutator_fn> id2 = br.mk_filter_identical_fn(*b2, 2, x2x3); (*id1)(*b1); (*ltx0x1)(*b1); (*ltx1x2)(*b1); b2->display(std::cout << "b2:\n"); (*id2)(*b2); b2->display(std::cout << "b2:\n"); (*ltx0x3)(*b2); b2->display(std::cout << "b2:\n"); scoped_ptr<relation_union_fn> u = br.mk_union_fn(*b1, *b2, 0); b1->display(std::cout << "b1:\n"); b2->display(std::cout << "b2:\n"); (*u)(*b1, *b2, 0); b1->display(std::cout << "b1 u b2:\n"); // TBD check property; b1->deallocate(); b2->deallocate(); } // test that equivalence classes are expanded. // { x1 = x2 = x3, x0 < x1} u { x1 = x3, x0 < x3, x0 < x2 } = { x0 < x2, x0 < x3 } { relation_base* b1 = br.mk_full(0, sig); relation_base* b2 = br.mk_full(0, sig); unsigned x0x3[2] = { 0, 3 }; unsigned x1x3[2] = { 1, 3 }; unsigned x2x3[2] = { 2, 3 }; scoped_ptr<relation_mutator_fn> id1 = br.mk_filter_identical_fn(*b1, 2, x1x3); scoped_ptr<relation_mutator_fn> id2 = br.mk_filter_identical_fn(*b1, 2, x2x3); scoped_ptr<relation_mutator_fn> ltx0x1 = br.mk_filter_interpreted_fn(*b1, lt_x0x1); scoped_ptr<relation_mutator_fn> ltx0x2 = br.mk_filter_interpreted_fn(*b2, lt_x0x2); scoped_ptr<relation_mutator_fn> ltx0x3 = br.mk_filter_interpreted_fn(*b2, lt_x0x3); scoped_ptr<relation_mutator_fn> id3 = br.mk_filter_identical_fn(*b2, 2, x1x3); (*id1)(*b1); (*id2)(*b1); (*ltx0x1)(*b1); (*id3)(*b2); (*ltx0x2)(*b2); (*ltx0x3)(*b2); scoped_ptr<relation_union_fn> u = br.mk_union_fn(*b1, *b2, 0); b1->display(std::cout << "b1:\n"); b2->display(std::cout << "b2:\n"); (*u)(*b1, *b2, 0); b1->display(std::cout << "b1 u b2:\n"); // TBD check property; b1->deallocate(); b2->deallocate(); } i1.deallocate(); i2.deallocate(); i3->deallocate(); i4->deallocate(); i5->deallocate(); dealloc(join1); dealloc(proj1); dealloc(ren1); dealloc(union1); dealloc(filterId1); dealloc(filterEq1); dealloc(filterCond1); }
int main(int argc, char* argv[]) { std::shared_ptr<Empty> blank; std::shared_ptr<Program> prg(new Program()); std::shared_ptr<SharedDecl> shDecl1(new SharedDecl("y", blank)); prg->Add(shDecl1); std::shared_ptr<Node> initX(new Atom("2")); std::shared_ptr<SharedDecl> shDecl2(new SharedDecl("x", initX)); prg->Add(shDecl2); std::shared_ptr<Sub> sub1(new Sub("Main")); sub1->AddParam("a"); sub1->AddParam("b"); prg->Add(sub1); std::shared_ptr<Atom> atomA(new Atom("a")); std::shared_ptr<Atom> atomB(new Atom("b")); std::shared_ptr<BinaryOp> initRes(new BinaryOp("add", atomA, atomB)); std::shared_ptr<VarDecl> resDecl(new VarDecl("res", initRes)); sub1->Add(resDecl); std::shared_ptr<Atom> atom3i(new Atom("3")); std::shared_ptr<Atom> atom5i(new Atom("5")); std::shared_ptr<BinaryOp> newParam(new BinaryOp("add", atom3i, atom5i)); std::shared_ptr<Allocation> allocat(new Allocation(newParam)); std::shared_ptr<Atom> atomArr(new Atom("arr")); std::shared_ptr<Assignation> asignNew3(new Assignation(atomArr, allocat)); sub1->Add(asignNew3); std::shared_ptr<Atom> atomArrBis(new Atom("arr")); std::shared_ptr<Deallocation> deallocat(new Deallocation(atomArrBis)); sub1->Add(deallocat); std::shared_ptr<Atom> atomC(new Atom("res")); std::shared_ptr<BinaryOp> subCsumAB(new BinaryOp("substract", atomC, initRes)); std::shared_ptr<Assignation> incC(new Assignation(atomC, subCsumAB)); sub1->Add(incC); std::shared_ptr<Atom> atom0(new Atom("0")); std::shared_ptr<BinaryOp> cond1cond(new BinaryOp("equals", atomC, atom0)); std::shared_ptr<If> cond1(new If(cond1cond, "10", "20")); sub1->Add(cond1); std::shared_ptr<Atom> atom1(new Atom("1")); std::shared_ptr<Atom> atom10(new Atom("10")); std::shared_ptr<For> for1(new For("i", atom1, atom10, atom1)); sub1->Add(for1); std::shared_ptr<BinaryOp> addC1(new BinaryOp("add", atomC, atom1)); std::shared_ptr<Assignation> incResActually(new Assignation(atomC, addC1)); for1->Add(incResActually); std::shared_ptr<Loop> loop1(new Loop(cond1cond)); loop1->Add(for1); // don't double reference ever in practice... loop1->Add(addC1); sub1->Add(loop1); std::shared_ptr<Call> call1(new Call("testFun", "")); call1->AddParam(atomA); call1->AddParam(addC1); sub1->Add(call1); std::shared_ptr<Return> ret1(new Return(atom0)); sub1->Add(ret1); XMLDumpVisitor v; prg->Accept(&v); return 0; }