/**************************************************************************************************
* IO
* ***********************************************************************************************/
Formula IO::readFromFile(const std::string fileName){
Formula result;
uint numberVars;
std::fstream data;
data.open(fileName, std::ios::in);
if(!data.is_open()){
std::cout << "Could not open: " << fileName;
exit(1);
}
while(!data.eof()){
std::string line;
getline(data, line);
if(line.empty()) continue;
if(line[0] == 'c' || line[0] == 'C') continue;
// Header line
if(line[0] == 'p'){
line = line.substr(line.find(" ")+1);
line = line.substr(line.find(" ")+1);
numberVars = std::stoi(line.substr(0, line.find(" ")));
result.setNumberOfVariables(numberVars);
continue;
}
result.addClauses(Clauses(line));
}
return result;
}
void MainWindow::impIClicked()
{
QList<QGraphicsItem *> selected_list = scene->selectedItems();
Node* selected = (Node*)(selected_list.at(0));
selected->setRule("impI");
selected->update();
Formula f = selected->getFormula();
Formula op1 = ((Imp*)f.get())->getOperand1();
Formula op2 = ((Imp*)f.get())->getOperand2();
std::ostringstream stream;
op2->printFormula(stream);
qreal rect_width = stream.str().length()*PARAMETER;
qreal rect_height = 20;
int rect_x = selected->getx() ;
int rect_y = selected->gety() - 20 - depth/2;
QVector<Formula> assumptions = selected->getAssumptions();
assumptions.push_back(op1);
Node* item = new Node( op2, rect_width, rect_height, rect_x, rect_y, selected_list.at(0), assumptions);
scene->addNode(item);
}
bool equalTo( const Formula & f) const
{
return f->getType() == this->getType() &&
_op1->equalTo(((BinaryConjective *)f.get())->getOperand1())
&&
_op2->equalTo(((BinaryConjective *)f.get())->getOperand2());
}
/**
* ((succ(_Y,_Z) & s(_X,_Z)) | theta__(_X,_Y)) -> s(_X,_Y)
* @return
*/
Formula HengZhang::createSuccAndSOrTheta__ImplS(const Formula& _originalFml) {
//1 (succ(_Y,_Z)
_term* term_y_z = Utils::combineTerms(m_vTermsY, m_vTermsZ);
_formula* succ_y_z = Utils::compositeToAtom(m_nSymbolSucc, term_y_z);
//2 s(_X,_Z)
_term* term_x_z = Utils::combineTerms(m_vTermsX, m_vTermsZ);
_formula* s_x_z = Utils::compositeToAtom(m_nSymbolS, term_x_z);
//3 theta__(_X,_Y)
Formula copyOriginalFml = _originalFml;
map<int, string> mapPredicates = Vocabulary::instance().getAllIntensionPredicates();
copyOriginalFml.doubleNegationPredicates(mapPredicates);
_formula* theta__ = Utils::copyFormula(copyOriginalFml.getFormula());
//4 s(_X,_Y)
_term* term_x_y = Utils::combineTerms(m_vTermsX, m_vTermsY);
_formula* s_x_y = Utils::compositeToAtom(m_nSymbolS, term_x_y);
//create structure
_formula* ll = Utils::compositeByConnective(CONJ, succ_y_z, s_x_z);
_formula* l = Utils::compositeByConnective(DISJ, ll, theta__);
_formula* r = s_x_y;
_formula* f = Utils::compositeByConnective(IMPL, l, r);
Formula fml = Formula(f, false);
return fml;
}
Formula Formula::differentiateWithRespectTo(std::string varName) {
using AST::Expression::Expression;
using AST::Expression::Text;
using AST::Visitor::GetDerivativeVisitor;
using AST::Visitor::StringifyVisitor;
using AST::Visitor::SimplifyVisitor;
if (formulaExpr == NULL) {
throw FormulaException("invalid formula");
}
std::unique_ptr<GetDerivativeVisitor> getDerivativeVisitorPtr(new GetDerivativeVisitor());
std::unique_ptr<SimplifyVisitor> simplifyVisitorPtr(new SimplifyVisitor());
std::unique_ptr<StringifyVisitor> stringifyVisitorPtr(new StringifyVisitor());
getDerivativeVisitorPtr.get()->setDerivativeVariableName(varName);
std::unique_ptr<Expression> derivativeExprPtr((Expression *)formulaExpr->accept(getDerivativeVisitorPtr.get()));
std::unique_ptr<Expression> simplifiedDerivativeExprPtr((Expression *)derivativeExprPtr.get()->accept(simplifyVisitorPtr.get()));
std::unique_ptr<Text> stringifiedDerivativeExprPtr((Text *)simplifiedDerivativeExprPtr.get()->accept(stringifyVisitorPtr.get()));
Formula derivative;
derivative.setFormulaString(stringifiedDerivativeExprPtr.get()->getContent());
derivative.setFormulaExpr(simplifiedDerivativeExprPtr.release());
return derivative;
}
/**
* 章衡量词消去公式五 2 succ(_Y,_Z) -> ((theta(_X,_Z) | t(_X,_Z)) -> t(_X,_Y))
* @param originalFml 一阶语句
* @return
*/
Formula HengZhang::createFormula_5_2(const Formula& _originalFml) {
//1 _succ(_Y,_Z)
_term* term_y_z = Utils::combineTerms(m_vTermsY, m_vTermsZ);
_formula* succ_y_z = Utils::compositeToAtom(m_nSymbolSucc, term_y_z);
//2 T(_X,_Y)
_term* term_x_y = Utils::combineTerms(m_vTermsX, m_vTermsY);
_formula* t_x_y = Utils::compositeToAtom(m_nSymbolT, term_x_y);
//3 theta(_X,_Z)
Formula copyOriginalFml = _originalFml;
copyOriginalFml.replaceTerms(m_vTermsY, m_vTermsZ);
_formula* theta_x_z = Utils::copyFormula(copyOriginalFml.getFormula());
//4 T(_X,_Z)
_term* term_x_z = Utils::combineTerms(m_vTermsX, m_vTermsZ);
_formula* t_x_z = Utils::compositeToAtom(m_nSymbolT, term_x_z);
//create structure
_formula* left = succ_y_z;
_formula* rl = Utils::compositeByConnective(DISJ, theta_x_z, t_x_z);
_formula* right = Utils::compositeByConnective(IMPL, rl, t_x_y);
_formula* F = Utils::compositeByConnective(IMPL, left, right);
Formula fml = Formula(F, false);
return fml;
}
void copyConsTest()
{
char str[100];
while (gets(str)) {
Parser p(str);
Formula *f = p.parse();
f->print();
puts("");
Predicate *pred = f->getPredicate();
Term *t = pred->getTermList()->getList()->at(0);
puts("here");
Term w = *t;
w.print();
puts("here");
w.setName("chan");
w.print();
puts("");
f->print();
puts("");
}
}
void formulaTest()
{
TermList *list = new TermList();
list->addTerm(new Term(Term::VAR, "x"));
list->addTerm(new Term(Term::VAR, NULL));
list->addTerm(new Term(Term::CONS, "A"));
Formula *f = new Formula(new Predicate("P", list));
Formula *g = new Formula(f);
Formula *q = new Formula(f, g, '&');
Formula *r = new Formula(new Term(Term::VAR, NULL), q, Formula::UNIV);
r->print();
Term *x = new Term(Term::VAR, "xy");
Term *y = new Term(Term::VAR, "x");
TermList *list2 = new TermList();
list2->addTerm(x);
list2->addTerm(y);
Term *f2 = new Term("f10", list2);
Term *g2 = new Term("f10", list2);
f2->print();
puts("");
g2->print();
puts("");
if (!(*f2 != *g2)) {
printf("yes! equal!");
}
}
bool Prover::isClosed(queue<Formula*> &q, int tabCount)
{
vector<Formula*> aList;
vector<Formula*> ntAList;
int sz = q.size();
for (int i = 0; i < sz; ++i) {
Formula *f = q.front();
q.pop();
q.push(f);
if (f->isAtomic()) {
aList.push_back(f);
}
else if (f->isNegated() && f->nextFormula->isAtomic()) {
ntAList.push_back(f->nextFormula);
}
}
for (int i = 0; i < aList.size(); i++) {
Formula *f1 = aList.at(i);
for (int j = 0; j < ntAList.size(); j++) {
Formula *f2 = ntAList.at(j);
if (!strcmp(f1->getPredicate()->getName(), f2->getPredicate()->getName())) {
//if (isUnifiable(f1->getPredicate()->getTermList(), f2->getPredicate()->getTermList())) {
if (isUnifiable(f1->getPredicate(), f2->getPredicate(), tabCount)) {
return true;
}
}
}
}
return false;
}
//
// Function: MULTIPLE.OPERATIONS
//
Value func_multiple_operations(valVector args, ValueCalc *, FuncExtra *e)
{
if (args.count() != 3 && args.count() != 5)
return Value::errorVALUE(); // invalid number of parameters
for (int i = 0; i < args.count(); i++) {
if (e->ranges[i].col1 == -1 || e->ranges[i].row1 == -1)
return Value::errorVALUE();
}
CellStorage *s = e->sheet->cellStorage();
// get formula to evaluate
int formulaCol = e->ranges[0].col1;
int formulaRow = e->ranges[0].row1;
Formula formula = s->formula(formulaCol, formulaRow);
if (!formula.isValid())
return Value::errorVALUE();
CellIndirection cellIndirections;
cellIndirections.insert(Cell(e->sheet, e->ranges[1].col1, e->ranges[1].row1), Cell(e->sheet, e->ranges[2].col1, e->ranges[2].row1));
if (args.count() > 3) {
cellIndirections.insert(Cell(e->sheet, e->ranges[3].col1, e->ranges[3].row1), Cell(e->sheet, e->ranges[4].col1, e->ranges[4].row1));
}
return formula.eval(cellIndirections);
}
Formula* Formula::getDelta(Term *newFunc)
{
Formula *f;
Term *v;
if (this->type == EXIST) {
f = this->nextFormula;
v = this->qVar;
}
else {
f = new Formula(this->nextFormula->getNext());
v = this->nextFormula->getQVar();
}
if (newFunc == NULL) {
TermList *list = new TermList();
f->getFreeVarList(list);
newFunc = new Term(NULL, list);
}
f->replace(v, newFunc);
return f;
}
int formulaDepth() const{
if(_op1->formulaDepth() > _op2->formulaDepth()){
return _op1->formulaDepth() + 1;
}
else{
return _op2->formulaDepth() + 1;
}
}
void EspressoData::add(EspressoCover &f, Formula::State state)
{
if (origFormula) {
Formula *formula = new Formula(*origFormula, f.cover);
formula->setState(state);
steps.push_back(formula);
}
}
// Function: ISFORMULA
Value func_isformula(valVector /*args*/, ValueCalc */*calc*/, FuncExtra *e)
{
const Calligra::Sheets::Region ®ion = e->regions[0];
QPoint p = region.firstRange().topLeft();
CellStorage *s = region.firstSheet()->cellStorage();
Formula formula = s->formula(p.x(), p.y());
return Value(formula.isValid());
}
bool AntimonyEvent::SetUseValuesFromTriggerTime(const Formula& form)
{
if (!form.IsBoolean()) {
g_registry.SetError("Unable to use '" + form.ToDelimitedStringWithEllipses(".") + "': only 'true' or 'false' may be used to set the value of 'fromTrigger' on an event.");
return true;
}
m_useValuesFromTriggerTime = form.GetBoolean();
return false;
}
bool AntimonyEvent::SetInitialValue(const Formula& form)
{
if (!form.IsBoolean()) {
g_registry.SetError("Unable to use '" + form.ToDelimitedStringWithEllipses(".") + "': only 'true' or 'false' may be used to set the value of 't0' (the initial value) of an event.");
return true;
}
m_initialValue = form.GetBoolean();
return false;
}
bool AntimonyEvent::SetPersistent(const Formula& form)
{
if (!form.IsBoolean()) {
g_registry.SetError("Unable to use '" + form.ToDelimitedStringWithEllipses(".") + "': only 'true' or 'false' may be used to set the value of 'persistent' on an event.");
return true;
}
m_persistent = form.GetBoolean();
return false;
}
void CreatorDialog::accept()
{
Formula *f = m_gm->getNewFormula();
if (f) {
f->setRepre(m_repre);
f->setName(m_name);
}
QDialog::accept();
}
bool Formula::operator==(Formula& other) {
bool sameBB = true;
sameBB = sameBB && this->getBoundingBox().getTopCoord() == other.getBoundingBox().getTopCoord();
sameBB = sameBB && this->getBoundingBox().getBottomCoord() == other.getBoundingBox().getBottomCoord();
sameBB = sameBB && this->getBoundingBox().getRightCoord() == other.getBoundingBox().getRightCoord();
sameBB = sameBB && this->getBoundingBox().getLeftCoord() == other.getBoundingBox().getLeftCoord();
return sameBB;
}
Formula* Formula::getAlpha2()
{
if (this->isCompound()) {
return this->formula2;
}
else {
Formula *next = this->nextFormula;
return new Formula(next->getRight());
}
}
void parseTest()
{
char str[100];
while (gets(str)) {
Parser p(str);
Formula *f = p.parse();
f->print();
formulaFeatureTest(f);
}
}
bool Formula::isBeta()
{
if (this->isCompound() && (this->cntv == '|' || this->cntv=='>')) {
return true;
}
else if (this->isNegated()) {
Formula *next = this->getNext();
if (next->isCompound() && next->getCntv()=='&') {
return true;
}
else return false;
}
else return false;
}
Formula* Formula::getBeta2()
{
if (this->isCompound()) {
return this->formula2;
}
else if (this->nextFormula->getCntv() == '&') {
Formula *next = this->nextFormula;
return new Formula(next->getRight());
}
else {
Formula *next = this->nextFormula;
return next->getRight();
}
}
Formula* Formula::getAlpha1()
{
if (this->isCompound()) {
return this->formula1;
}
else if (this->nextFormula->getCntv() == '|') {
Formula *next = this->nextFormula;
return new Formula(next->getLeft());
}
else {
Formula *next = this->nextFormula;
return next->getLeft();
}
}
/**
* 章衡量词消去公式三 t(_X,_MIN) | theta(_X,_MIN)
* @param originalFml 一阶语句
* @return
*/
Formula HengZhang::createFormula_3(const Formula& _originalFml) {
//create left sub-formula t(_X,_MIN)
_term* term_x_min = Utils::combineTerms(m_vTermsX, m_vTermsMIN);
_formula* t_x_min = Utils::compositeToAtom(m_nSymbolT, term_x_min);
//create right sub-formula theta(_X,_MIN)
Formula copyOriginalFml = _originalFml;
copyOriginalFml.replaceTerms(m_vTermsY, m_vTermsMIN);
_formula* theta_x_min = Utils::copyFormula(copyOriginalFml.getFormula());
//create structure
_formula* F = Utils::compositeByConnective(DISJ, t_x_min, theta_x_min);
Formula fml = Formula(F, false);
return fml;
}
static QString tokenizeFormula(const QString& formula)
{
Formula f;
QString expr = formula;
expr.prepend( '=' );
f.setExpression( expr );
Tokens tokens = f.tokens();
QString resultCodes;
if( tokens.valid() )
for( int i = 0; i < tokens.count(); i++ )
resultCodes.append( encodeTokenType( tokens[i] ) );
return resultCodes;
}
/**
* 把量词保存到对应的vector
* @param originalFml 一阶语句
* @return
*/
Formula HengZhang::recordQuantifier(const Formula& _originalFml) {
m_vTermsX.clear();
m_vTermsY.clear();
m_vTermsZ.clear();
m_vTermsMIN.clear();
m_vTermsMAX.clear();
_formula* fml = _originalFml.getFormula();
while(fml->formula_type == UNIV) {
m_vTermsX.push_back(fml->variable_id);
fml = fml->subformula_l;
}
while (fml->formula_type == EXIS) {
m_vTermsY.push_back(fml->variable_id);
const char* sDomainName = Vocabulary::instance().getVariableDomain(fml->variable_id);
// MIN
int id = Vocabulary::instance().generateDomainMIN(sDomainName);
m_vTermsMIN.push_back(id);
// MAX
id = Vocabulary::instance().generateDomainMAX(sDomainName);
m_vTermsMAX.push_back(id);
// Z
id = Vocabulary::instance().generateNewVariable(fml->variable_id);
m_vTermsZ.push_back(id);
fml = fml->subformula_l;
}
Formula ret = Formula(fml, true);
return ret;
}
Value TestTextFunctions::evaluate(const QString& formula, Value& ex)
{
Formula f;
QString expr = formula;
if (expr[0] != '=')
expr.prepend('=');
f.setExpression(expr);
Value result = f.eval();
if (result.isFloat() && ex.isInteger())
ex = Value(ex.asFloat());
if (result.isInteger() && ex.isFloat())
result = Value(result.asFloat());
return result;
}
/**
* 对每条公式进行章衡公式转换
* @param _originalFmls Formulas 需要进行转换的公式
* @return 返回Formulas*，需要手动销毁
*/
Formulas* HengZhang::convert(const Formulas& _originalFmls) {
Formulas tempFmls = _originalFmls;
Formulas* pFinalFmls = new Formulas();
while (! tempFmls.isEmpty()) {
Formula curFml = tempFmls.popFront();
curFml.convertToPNF();
if (curFml.isUniversal()) {
pFinalFmls->pushBack(curFml);
continue;
}
Formulas hzFmls = transform(curFml);
tempFmls.joinFront(hzFmls);
}
return pFinalFmls;
}
Formula* Formula::getGamma(Term *newV)
{
Formula *f;
Term *v;
if (this->type == UNIV) {
f = this->nextFormula;
v = this->qVar;
}
else {
f = new Formula(this->nextFormula->getNext());
v = this->nextFormula->getQVar();
}
f->replace(v, newV);
return f;
}
