void ArithStaticLearner::addBound(TNode n) { CDNodeToMinMaxMap::const_iterator minFind = d_minMap.find(n[0]); CDNodeToMinMaxMap::const_iterator maxFind = d_maxMap.find(n[0]); Rational constant = n[1].getConst<Rational>(); DeltaRational bound = constant; switch(Kind k = n.getKind()) { case kind::LT: bound = DeltaRational(constant, -1); /* fall through */ case kind::LEQ: if (maxFind == d_maxMap.end() || (*maxFind).second > bound) { d_maxMap.insert(n[0], bound); Debug("arith::static") << "adding bound " << n << endl; } break; case kind::GT: bound = DeltaRational(constant, 1); /* fall through */ case kind::GEQ: if (minFind == d_minMap.end() || (*minFind).second < bound) { d_minMap.insert(n[0], bound); Debug("arith::static") << "adding bound " << n << endl; } break; default: Unhandled(k); break; } }
std::ostream& operator<<(std::ostream& os, const Algorithms a){ switch(a){ case None: os << "AlgNone"; break; case Lookup: os << "AlgLookup"; break; case RowSum: os << "AlgRowSum"; break; case Simplex: os << "AlgSimplex"; break; default: Unhandled(); } return os; }
ostream& operator<<(ostream& out, enum Result::Validity v) { switch (v) { case Result::INVALID: out << "INVALID"; break; case Result::VALID: out << "VALID"; break; case Result::VALIDITY_UNKNOWN: out << "VALIDITY_UNKNOWN"; break; default: Unhandled(v); } return out; }
ostream& operator<<(ostream& out, enum Result::Sat s) { switch (s) { case Result::UNSAT: out << "UNSAT"; break; case Result::SAT: out << "SAT"; break; case Result::SAT_UNKNOWN: out << "SAT_UNKNOWN"; break; default: Unhandled(s); } return out; }
void PicklerPrivate::toCaseConstant(TNode n) { Kind k = n.getKind(); Assert(metaKindOf(k) == kind::metakind::CONSTANT); switch(k) { case kind::CONST_BOOLEAN: d_current << mkConstantHeader(k, 1); d_current << mkBlockBody(n.getConst<bool>()); break; case kind::CONST_RATIONAL: { std::string asString; Assert(k == kind::CONST_RATIONAL); const Rational& q = n.getConst<Rational>(); asString = q.toString(16); toCaseString(k, asString); break; } case kind::BITVECTOR_EXTRACT_OP: { BitVectorExtract bve = n.getConst<BitVectorExtract>(); d_current << mkConstantHeader(k, 2); d_current << mkBlockBody(bve.high); d_current << mkBlockBody(bve.low); break; } case kind::CONST_BITVECTOR: { // irritating: we incorporate the size of the string in with the // size of this constant, so it appears as one big constant and // doesn't confuse anybody BitVector bv = n.getConst<BitVector>(); std::string asString = bv.getValue().toString(16); d_current << mkConstantHeader(k, 2 + asString.size()); d_current << mkBlockBody(bv.getSize()); toCaseString(k, asString); break; } case kind::BITVECTOR_SIGN_EXTEND_OP: { BitVectorSignExtend bvse = n.getConst<BitVectorSignExtend>(); d_current << mkConstantHeader(k, 1); d_current << mkBlockBody(bvse.signExtendAmount); break; } default: Unhandled(k); } }
std::ostream& operator<<(std::ostream& os, EqualityStatus s) { switch (s) { case EQUALITY_TRUE_AND_PROPAGATED: os << "EQUALITY_TRUE_AND_PROPAGATED"; break; case EQUALITY_FALSE_AND_PROPAGATED: os << "EQUALITY_FALSE_AND_PROPAGATED"; break; case EQUALITY_TRUE: os << "EQUALITY_TRUE"; break; case EQUALITY_FALSE: os << "EQUALITY_FALSE"; break; case EQUALITY_TRUE_IN_MODEL: os << "EQUALITY_TRUE_IN_MODEL"; break; case EQUALITY_FALSE_IN_MODEL: os << "EQUALITY_FALSE_IN_MODEL"; break; case EQUALITY_UNKNOWN: os << "EQUALITY_UNKNOWN"; break; default: Unhandled(); break; } return os; }
bool checkConstantMembership(TNode elementTerm, TNode setTerm) { switch(setTerm.getKind()) { case kind::EMPTYSET: return false; case kind::SET_SINGLETON: return elementTerm == setTerm[0]; case kind::UNION: return checkConstantMembership(elementTerm, setTerm[0]) || checkConstantMembership(elementTerm, setTerm[1]); case kind::INTERSECTION: return checkConstantMembership(elementTerm, setTerm[0]) && checkConstantMembership(elementTerm, setTerm[1]); case kind::SETMINUS: return checkConstantMembership(elementTerm, setTerm[0]) && !checkConstantMembership(elementTerm, setTerm[1]); default: Unhandled(); } }
void PicklerPrivate::toCaseNode(TNode n) { Debug("pickler") << "toCaseNode: " << n << std::endl; Kind k = n.getKind(); kind::MetaKind m = metaKindOf(k); switch(m) { case kind::metakind::CONSTANT: toCaseConstant(n); break; case kind::metakind::VARIABLE: toCaseVariable(n); break; case kind::metakind::OPERATOR: case kind::metakind::PARAMETERIZED: toCaseOperator(n); break; default: Unhandled(m); } }
void Theory$camel::check(Effort level) { while(!done()) { // Get all the assertions Assertion assertion = get(); TNode fact = assertion.assertion; Debug("$dir") << "Theory$camel::check(): processing " << fact << std::endl; // Do the work switch(fact.getKind()) { /* cases for all the theory's kinds go here... */ default: Unhandled(fact.getKind()); } } }/* Theory$camel::check() */
Expr Pickler::fromPickle(Pickle& p) { Assert(d_private->atDefaultState()); d_private->d_current.swap(*p.d_data); while(!d_private->d_current.empty()) { Block front = d_private->d_current.dequeue(); Kind k = (Kind)front.d_header.d_kind; kind::MetaKind m = metaKindOf(k); Node result = Node::null(); switch(m) { case kind::metakind::VARIABLE: result = d_private->fromCaseVariable(k); break; case kind::metakind::CONSTANT: result = d_private->fromCaseConstant(k, front.d_headerConstant.d_constblocks); break; case kind::metakind::OPERATOR: case kind::metakind::PARAMETERIZED: result = d_private->fromCaseOperator(k, front.d_headerOperator.d_nchildren); break; default: Unhandled(m); } Assert(result != Node::null()); d_private->d_stack.push(result); } Assert(d_private->d_current.empty()); Assert(d_private->d_stack.size() == 1); Node res = d_private->d_stack.top(); d_private->d_stack.pop(); Assert(d_private->atDefaultState()); return d_private->d_nm->toExpr(res); }
Node PicklerPrivate::fromCaseConstant(Kind k, uint32_t constblocks) { switch(k) { case kind::CONST_BOOLEAN: { Assert(constblocks == 1); Block val = d_current.dequeue(); bool b= val.d_body.d_data; return d_nm->mkConst<bool>(b); } case kind::CONST_RATIONAL: { std::string s = fromCaseString(constblocks); Rational q(s, 16); return d_nm->mkConst<Rational>(q); } case kind::BITVECTOR_EXTRACT_OP: { Block high = d_current.dequeue(); Block low = d_current.dequeue(); BitVectorExtract bve(high.d_body.d_data, low.d_body.d_data); return d_nm->mkConst<BitVectorExtract>(bve); } case kind::CONST_BITVECTOR: { unsigned size = d_current.dequeue().d_body.d_data; Block header CVC4_UNUSED = d_current.dequeue(); Assert(header.d_headerConstant.d_kind == kind::CONST_BITVECTOR); Assert(header.d_headerConstant.d_constblocks == constblocks - 2); Integer value(fromCaseString(constblocks - 2)); BitVector bv(size, value); return d_nm->mkConst(bv); } case kind::BITVECTOR_SIGN_EXTEND_OP: { Block signExtendAmount = d_current.dequeue(); BitVectorSignExtend bvse(signExtendAmount.d_body.d_data); return d_nm->mkConst<BitVectorSignExtend>(bvse); } default: Unhandled(k); } }
ostream& operator<<(ostream& out, enum Result::UnknownExplanation e) { switch (e) { case Result::REQUIRES_FULL_CHECK: out << "REQUIRES_FULL_CHECK"; break; case Result::INCOMPLETE: out << "INCOMPLETE"; break; case Result::TIMEOUT: out << "TIMEOUT"; break; case Result::RESOURCEOUT: out << "RESOURCEOUT"; break; case Result::MEMOUT: out << "MEMOUT"; break; case Result::INTERRUPTED: out << "INTERRUPTED"; break; case Result::NO_STATUS: out << "NO_STATUS"; break; case Result::UNSUPPORTED: out << "UNSUPPORTED"; break; case Result::OTHER: out << "OTHER"; break; case Result::UNKNOWN_REASON: out << "UNKNOWN_REASON"; break; default: Unhandled(e); } return out; }
Result Result::asValidityResult() const { if (d_which == TYPE_VALIDITY) { return *this; } if (d_which == TYPE_SAT) { switch (d_sat) { case SAT: return Result(INVALID, d_inputName); case UNSAT: return Result(VALID, d_inputName); case SAT_UNKNOWN: return Result(VALIDITY_UNKNOWN, d_unknownExplanation, d_inputName); default: Unhandled(d_sat); } } // TYPE_NONE return Result(VALIDITY_UNKNOWN, NO_STATUS, d_inputName); }
Result Result::asSatisfiabilityResult() const { if (d_which == TYPE_SAT) { return *this; } if (d_which == TYPE_VALIDITY) { switch (d_validity) { case INVALID: return Result(SAT, d_inputName); case VALID: return Result(UNSAT, d_inputName); case VALIDITY_UNKNOWN: return Result(SAT_UNKNOWN, d_unknownExplanation, d_inputName); default: Unhandled(d_validity); } } // TYPE_NONE return Result(SAT_UNKNOWN, NO_STATUS, d_inputName); }
std::string LogicInfo::getLogicString() const { CheckArgument(d_locked, *this, "This LogicInfo isn't locked yet, and cannot be queried"); if(d_logicString == "") { LogicInfo qf_all_supported; qf_all_supported.disableQuantifiers(); qf_all_supported.lock(); if(hasEverything()) { d_logicString = "ALL_SUPPORTED"; } else if(*this == qf_all_supported) { d_logicString = "QF_ALL_SUPPORTED"; } else { size_t seen = 0; // make sure we support all the active theories stringstream ss; if(!isQuantified()) { ss << "QF_"; } if(d_theories[THEORY_ARRAY]) { ss << (d_sharingTheories == 1 ? "AX" : "A"); ++seen; } if(d_theories[THEORY_UF]) { ss << "UF"; ++seen; } if(d_theories[THEORY_BV]) { ss << "BV"; ++seen; } if(d_theories[THEORY_DATATYPES]) { ss << "DT"; ++seen; } if(d_theories[THEORY_ARITH]) { if(isDifferenceLogic()) { ss << (areIntegersUsed() ? "I" : ""); ss << (areRealsUsed() ? "R" : ""); ss << "DL"; } else { ss << (isLinear() ? "L" : "N"); ss << (areIntegersUsed() ? "I" : ""); ss << (areRealsUsed() ? "R" : ""); ss << "A"; } ++seen; } if(seen != d_sharingTheories) { Unhandled("can't extract a logic string from LogicInfo; at least one " "active theory is unknown to LogicInfo::getLogicString() !"); } if(seen == 0) { ss << "SAT"; } d_logicString = ss.str(); } } return d_logicString; }