[mathprog] file update (segfault fix)
- From: Yonatan Ben-Yaakov <yontanbn@xxxxxxxxxxxxx>
- To: mathprog@xxxxxxxxxxxxx
- Date: Fri, 20 Sep 2002 18:18:14 +0300 (IDT)
hey all
i fixed a segfault in the getAllPossibleSubstitutions method,
As usual, find changed files attached
- Yonatan.
#include "Sentence.h"
#include "PointerComparator.h"
#include "Tools.h"
#include <sstream>
#include <vector>
#include <list>
using namespace::std;
Sentence::Sentence() {}
Sentence::~Sentence() {}
WorldValueSentence::WorldValueSentence(string s): name(s) {}
const string WorldValueSentence::getName() const {
return name;
}
TruthValueSentence::TruthValueSentence() {}
ConstantSentence::ConstantSentence(string s): WorldValueSentence(s) {}
string ConstantSentence::toString() const {
return name;
}
bool ConstantSentence::equals(const Sentence* s) const {
const ConstantSentence* cs;
if ((cs = dynamic_cast<const ConstantSentence*>(s))) {
return (cs->name == name);
}
else
return false;
}
pair<bool, ConstantSentence*> ConstantSentence::equalsUpToSubstitution(const
Sentence* s, const VariableSentence* v) const {
if (equals(s))
return pair<bool, ConstantSentence*>(true, 0);
else
return pair<bool, ConstantSentence*>(false, 0);
}
ConstantSentence* ConstantSentence::clone(const VariableSentence* v, const
ConstantSentence* c) const {
return new ConstantSentence(name);
}
bool ConstantSentence::containsConstant(const ConstantSentence* c) const {
return equals(c);
}
list<Sentence*>* ConstantSentence::getAllPossibleSubstitutions(const
ConstantSentence* original, const ConstantSentence* substitute) const {
list<Sentence*>* l = new list<Sentence*>;
if (equals(original))
l->push_back(substitute->clone());
l->push_back(clone());
return l;
}
VariableSentence::VariableSentence(string s): WorldValueSentence(s) {}
string VariableSentence::toString() const {
return name;
}
bool VariableSentence::equals(const Sentence* s) const {
const VariableSentence* vs;
if ((vs = dynamic_cast<const VariableSentence*>(s))) {
return (vs->name == name);
}
else
return false;
}
pair<bool, ConstantSentence*> VariableSentence::equalsUpToSubstitution(const
Sentence* s, const VariableSentence* v) const {
if (!equals(v)) {
if (equals(s))
return pair<bool, ConstantSentence*>(true, 0);
else
return pair<bool, ConstantSentence*>(false, 0);
}
// equals(v), so we know we're dealing with a variable that we're substituting
// the sentence must be a constant, for it to work
const ConstantSentence* cs;
if ((cs = dynamic_cast<const ConstantSentence*>(s))) {
return pair<bool, ConstantSentence*>(true, cs->clone());
}
else
return pair<bool, ConstantSentence*>(false, 0);
}
// returns either VariableSentence or ConstantSentence, depending on whether or
not a substition was made
WorldValueSentence* VariableSentence::clone(const VariableSentence* v, const
ConstantSentence* c) const {
if (v && equals(v))
return c->clone();
else
return new VariableSentence(name);
}
bool VariableSentence::containsConstant(const ConstantSentence* c) const {
return false;
}
list<Sentence*>* VariableSentence::getAllPossibleSubstitutions(const
ConstantSentence* original, const ConstantSentence* substitute) const {
list<Sentence*>* l = new list<Sentence*>;
l->push_back(clone());
return l;
}
FunctionSentence::FunctionSentence(): WorldValueSentence("") {}
FunctionSentence::FunctionSentence(string s, WorldValueSentence* par):
WorldValueSentence(s), arity(1) {
parameters = new list<WorldValueSentence*>();
parameters->push_back(par);
}
FunctionSentence::FunctionSentence(string s, WorldValueSentence* par1,
WorldValueSentence* par2):
WorldValueSentence(s), arity(2) {
parameters = new list<WorldValueSentence*>();
parameters->push_back(par1);
parameters->push_back(par2);
}
FunctionSentence::FunctionSentence(string s, list<WorldValueSentence*>* l):
WorldValueSentence(s), parameters(l) {
if (l != 0) { // should throw something if it IS!
arity = l->size();
}
}
FunctionSentence::~FunctionSentence() {
for (list<WorldValueSentence*>::iterator it = parameters->begin();
it != parameters->end(); it++) {
delete(*it);
}
delete parameters;
}
string FunctionSentence::toString() const {
stringstream s;
s << name << "_" << arity << "(";
list<WorldValueSentence*>::const_iterator it = parameters->begin();
if (it == parameters->end()) {
s << ")";
return s.str();
}
s << (*it)->toString();
for (it++; it != parameters->end(); it++) {
s << ", ";
s << (*it)->toString();
}
s << ")";
return s.str();
}
int FunctionSentence::getArity() const {
return arity;
}
const list<WorldValueSentence*>* FunctionSentence::getParameters() const {
return parameters;
}
bool FunctionSentence::equals(const Sentence* s) const {
const FunctionSentence* fs;
if ((fs = dynamic_cast<const FunctionSentence*>(s))) {
if ((fs->name == name) && (fs->arity == arity) &&
(std::equal(fs->parameters->begin(), fs->parameters->end(),
parameters->begin(), PointerComparator<Sentence>())))
return true;
}
return false;
}
pair<bool, ConstantSentence*> FunctionSentence::equalsUpToSubstitution(const
Sentence* s, const VariableSentence* v) const {
const FunctionSentence* fs;
if ((fs = dynamic_cast<const FunctionSentence*>(s))) {
if ((fs->name == name) && (fs->arity == arity)) {
ConstantSentence* a = 0;
list<WorldValueSentence*>::const_iterator it1, it2;
for (it1 = parameters->begin(), it2 = fs->parameters->begin();
it1 != parameters->end(); it1++, it2++) {
pair<bool, ConstantSentence*> res =
(*it1)->equalsUpToSubstitution(*it2, v);
if (!res.first)
return pair<bool, ConstantSentence*>(false, 0);
if (res.second) {
if (a) {
if (*a != *(res.second)) {
return pair<bool, ConstantSentence*>(false, 0);
}
}
else {
a = res.second;
}
}
}
return pair<bool, ConstantSentence*>(true, a->clone());
}
}
return pair<bool, ConstantSentence*>(false, 0);
}
FunctionSentence* FunctionSentence::clone(const VariableSentence* v, const
ConstantSentence* c) const {
FunctionSentence* fs = new FunctionSentence();
fs->name = name;
fs->arity = arity;
fs->parameters = new list<WorldValueSentence*>;
for (list<WorldValueSentence*>::const_iterator it = parameters->begin();
it != parameters->end(); it++) {
WorldValueSentence* wv = (*it)->clone(v, c);
fs->parameters->push_back(wv);
}
return fs;
}
bool FunctionSentence::containsConstant(const ConstantSentence* c) const {
for (list<WorldValueSentence*>::const_iterator it = parameters->begin();
it != parameters->end(); it++) {
if ((*it)->containsConstant(c))
return true;
}
return false;
}
list<Sentence*>* FunctionSentence::getAllPossibleSubstitutions(const
ConstantSentence* original, const ConstantSentence* substitute) const {
list<Sentence*>* l = new list<Sentence*>();
vector<const list<Sentence*>*> inp;
list<WorldValueSentence*>::const_iterator it;
for (it = parameters->begin(); it != parameters->end(); it++) {
inp.push_back((*it)->getAllPossibleSubstitutions(original, substitute));
}
list<vector<Sentence*>*>* res = Tools::expoMerge<Sentence>(arity, &inp);
for (list<vector<Sentence*>*>::iterator it = res->begin(); it != res->end();
it++) {
list<WorldValueSentence*>* p = new list<WorldValueSentence*>();
for (vector<Sentence*>::iterator it2 = (*it)->begin(); it2 != (*it)->end();
it2++) {
p->push_back(dynamic_cast<WorldValueSentence*>(*it2));
}
FunctionSentence* f = new FunctionSentence(name, p);
l->push_back(f);
}
return l;
}
PredicateSentence::PredicateSentence() {}
PredicateSentence::PredicateSentence(string s, WorldValueSentence* par):
name(s),
arity(1) {
parameters = new list<WorldValueSentence*>();
parameters->push_back(par);
}
PredicateSentence::PredicateSentence(string s, WorldValueSentence* par1,
WorldValueSentence* par2): name(s), arity(2) {
parameters = new list<WorldValueSentence*>();
parameters->push_back(par1);
parameters->push_back(par2);
}
PredicateSentence::PredicateSentence(string s, list<WorldValueSentence*>* l):
name(s), parameters(l) {
if (l != 0) { // should throw something if it IS!
arity = l->size();
}
}
PredicateSentence::~PredicateSentence() {
for (list<WorldValueSentence*>::iterator it = parameters->begin();
it != parameters->end(); it++) {
delete(*it);
}
delete parameters;
}
string PredicateSentence::toString() const {
stringstream s;
s << name << "_" << arity << "(";
list<WorldValueSentence*>::const_iterator it = parameters->begin();
if (it == parameters->end()) {
s << ")";
return s.str();
}
s << (*it)->toString();
for (it++; it != parameters->end(); it++) {
s << ", ";
s << (*it)->toString();
}
s << ")";
return s.str();
}
const string PredicateSentence::getName() const {
return name;
}
int PredicateSentence::getArity() const {
return arity;
}
const std::list<WorldValueSentence*>* PredicateSentence::getParameters() const {
return parameters;
}
bool PredicateSentence::equals(const Sentence* s) const {
const PredicateSentence* ps;
if ((ps = dynamic_cast<const PredicateSentence*>(s))) {
if ((ps->name == name) && (ps->arity == arity) &&
(equal(ps->parameters->begin(), ps->parameters->end(),
parameters->begin(), PointerComparator<Sentence>())))
return true;
}
return false;
}
pair<bool, ConstantSentence*> PredicateSentence::equalsUpToSubstitution(const
Sentence* s, const VariableSentence* v) const {
const PredicateSentence* ps;
if ((ps = dynamic_cast<const PredicateSentence*>(s))) {
if ((ps->name == name) && (ps->arity == arity)) {
ConstantSentence* a = 0;
list<WorldValueSentence*>::const_iterator it1, it2;
for (it1 = parameters->begin(), it2 = ps->parameters->begin();
it1 != parameters->end(); it1++, it2++) {
pair<bool, ConstantSentence*> res =
(*it1)->equalsUpToSubstitution(*it2, v);
if (!res.first)
return pair<bool, ConstantSentence*>(false, 0);
if (res.second) {
if (a) {
if (*a != *(res.second)) {
return pair<bool, ConstantSentence*>(false, 0);
}
}
else {
a = res.second;
}
}
}
return pair<bool, ConstantSentence*>(true, a->clone());
}
}
return pair<bool, ConstantSentence*>(false, 0);
}
PredicateSentence* PredicateSentence::clone(const VariableSentence* v, const
ConstantSentence* c) const {
PredicateSentence* ps = new PredicateSentence();
ps->name = name;
ps->arity = arity;
ps->parameters = new list<WorldValueSentence*>;
for (list<WorldValueSentence*>::const_iterator it = parameters->begin();
it != parameters->end(); it++) {
WorldValueSentence* wv = (*it)->clone(v, c);
ps->parameters->push_back(wv);
}
return ps;
}
bool PredicateSentence::containsConstant(const ConstantSentence* c) const {
for (list<WorldValueSentence*>::const_iterator it = parameters->begin();
it != parameters->end(); it++) {
if ((*it)->containsConstant(c))
return true;
}
return false;
}
list<Sentence*>* PredicateSentence::getAllPossibleSubstitutions(const
ConstantSentence* original, const ConstantSentence* substitute) const {
list<Sentence*>* l = new list<Sentence*>();
vector<const list<Sentence*>*> inp;
list<WorldValueSentence*>::const_iterator it;
for (it = parameters->begin(); it != parameters->end(); it++) {
inp.push_back((*it)->getAllPossibleSubstitutions(original, substitute));
}
list<vector<Sentence*>*>* res = Tools::expoMerge<Sentence>(arity, &inp);
for (list<vector<Sentence*>*>::iterator it = res->begin(); it != res->end();
it++) {
list<WorldValueSentence*>* p = new list<WorldValueSentence*>();
for (vector<Sentence*>::iterator it2 = (*it)->begin(); it2 != (*it)->end();
it2++) {
p->push_back(dynamic_cast<WorldValueSentence*>(*it2));
}
PredicateSentence* f = new PredicateSentence(name, p);
l->push_back(f);
}
return l;
}
EqualitySentence::EqualitySentence(WorldValueSentence* f, WorldValueSentence*
s):
first(f), second(s) {}
EqualitySentence::~EqualitySentence() {
delete first;
delete second;
}
string EqualitySentence::toString() const {
string s;
s += "(";
s += first->toString();
s += ")";
s += "=";
s += "(";
s += second->toString();
s += ")";
return s;
}
const WorldValueSentence* EqualitySentence::getFirst() const {
return first;
}
const WorldValueSentence* EqualitySentence::getSecond() const {
return second;
}
bool EqualitySentence::equals(const Sentence* s) const {
const EqualitySentence* es;
if ((es = dynamic_cast<const EqualitySentence*>(s))) {
if ((*first == *es->first) && (*second == *es->second))
return true;
}
return false;
}
pair<bool, ConstantSentence*> EqualitySentence::equalsUpToSubstitution(const
Sentence* s, const VariableSentence* v) const {
const EqualitySentence* es;
if ((es = dynamic_cast<const EqualitySentence*>(s))) {
pair<bool, ConstantSentence*> res1 =
first->equalsUpToSubstitution(es->first, v);
if (!res1.first)
return pair<bool, ConstantSentence*>(false, 0);
pair<bool, ConstantSentence*> res2 =
second->equalsUpToSubstitution(es->second, v);
if (!res2.first)
return pair<bool, ConstantSentence*>(false, 0);
// now we know res1.first and res2.first
if (res1.second) {
if (res2.second) {
if (*(res1.second) == *(res2.second))
return pair<bool, ConstantSentence*>(true, res1.second->clone());
else
return pair<bool, ConstantSentence*>(false, 0);
}
else
return pair<bool, ConstantSentence*>(true, res1.second->clone());
}
else {
if (res2.second)
return pair<bool, ConstantSentence*>(true, res2.second->clone());
else
return pair<bool, ConstantSentence*>(true, 0);
}
}
return pair<bool, ConstantSentence*>(false, 0);
}
EqualitySentence* EqualitySentence::clone(const VariableSentence* v, const
ConstantSentence* c) const {
return new EqualitySentence(first->clone(v, c), second->clone(v, c));
}
bool EqualitySentence::containsConstant(const ConstantSentence* c) const {
return (first->containsConstant(c) || second->containsConstant(c));
}
list<Sentence*>* EqualitySentence::getAllPossibleSubstitutions(const
ConstantSentence* original, const ConstantSentence* substitute) const {
list<Sentence*>* l = new list<Sentence*>();
list<pair<Sentence*, Sentence*> >* res =
Tools::expoMerge<Sentence,
Sentence>(first->getAllPossibleSubstitutions(original, substitute),
second->getAllPossibleSubstitutions(original, substitute));
for (list<pair<Sentence*, Sentence*> >::iterator it = res->begin(); it !=
res->end(); it++) {
l->push_back(new
EqualitySentence(dynamic_cast<WorldValueSentence*>(it->first),
dynamic_cast<WorldValueSentence*>(it->second)));
}
return l;
}
OperatorSentence::OperatorSentence(int o, TruthValueSentence* f,
TruthValueSentence* s = 0): op(o), firstOperand(f), secondOperand(s) {}
OperatorSentence::~OperatorSentence() {
delete firstOperand;
delete secondOperand;
}
string OperatorSentence::toString() const {
string s;
if (op == NOT) {
s += "NOT(";
s += firstOperand->toString();
s += ")";
}
else {
s += "(";
s += firstOperand->toString();
s += ")";
switch (op) {
case AND: s += " AND "; break;
case OR: s += " OR "; break;
case IMPLIES: s+= " ==> "; break;
case IMPLIED: s+= " <== "; break;
case IFF: s += " <==> "; break;
}
s += "(";
s += secondOperand->toString();
s += ")";
}
return s;
}
int OperatorSentence::getOp() const {
return op;
}
const TruthValueSentence* OperatorSentence::getFirstOperand() const {
return firstOperand;
}
const TruthValueSentence* OperatorSentence::getSecondOperand() const {
return secondOperand;
}
bool OperatorSentence::equals(const Sentence* s) const {
const OperatorSentence* os;
if ((os = dynamic_cast<const OperatorSentence*>(s))) {
if ((*firstOperand == *os->firstOperand)) {
if (((!secondOperand) && (!os->secondOperand)) ||
(secondOperand && os->secondOperand && *secondOperand ==
*os->secondOperand))
return true;
}
}
return false;
}
pair<bool, ConstantSentence*> OperatorSentence::equalsUpToSubstitution(const
Sentence* s, const VariableSentence* v) const {
const OperatorSentence* os;
if ((os = dynamic_cast<const OperatorSentence*>(s))) {
pair<bool, ConstantSentence*> res1 =
firstOperand->equalsUpToSubstitution(os->firstOperand, v);
if (!res1.first)
return pair<bool, ConstantSentence*>(false, 0);
if (!secondOperand) {
if (res1.second)
return pair<bool, ConstantSentence*>(true, res1.second->clone());
else
return pair<bool, ConstantSentence*>(true, 0);
}
pair<bool, ConstantSentence*> res2 =
secondOperand->equalsUpToSubstitution(os->secondOperand, v);
if (!res2.first)
return pair<bool, ConstantSentence*>(false, 0);
// now we know res1.first and res2.first
if (res1.second) {
if (res2.second) {
if (*(res1.second) == *(res2.second))
return pair<bool, ConstantSentence*>(true, res1.second->clone());
else
return pair<bool, ConstantSentence*>(false, 0);
}
else
return pair<bool, ConstantSentence*>(true, res1.second->clone());
}
else {
if (res2.second)
return pair<bool, ConstantSentence*>(true, res2.second->clone());
else
return pair<bool, ConstantSentence*>(true, 0);
}
}
return pair<bool, ConstantSentence*>(false, 0);
}
OperatorSentence* OperatorSentence::clone(const VariableSentence* v, const
ConstantSentence* c) const {
return new OperatorSentence(op, firstOperand->clone(v, c),
secondOperand->clone(v, c));
}
bool OperatorSentence::containsConstant(const ConstantSentence* c) const {
return (firstOperand->containsConstant(c) ||
secondOperand->containsConstant(c));
}
list<Sentence*>* OperatorSentence::getAllPossibleSubstitutions(const
ConstantSentence* original, const ConstantSentence* substitute) const {
list<Sentence*>* l = new list<Sentence*>();
list<pair<Sentence*, Sentence*> >* res =
Tools::expoMerge<Sentence,
Sentence>(firstOperand->getAllPossibleSubstitutions(original, substitute),
secondOperand->getAllPossibleSubstitutions(original, substitute));
for (list<pair<Sentence*, Sentence*> >::iterator it = res->begin(); it !=
res->end(); it++) {
l->push_back(new OperatorSentence(op,
dynamic_cast<TruthValueSentence*>(it->first),
dynamic_cast<TruthValueSentence*>(it->second)));
}
return l;
}
QuantifierSentence::QuantifierSentence(int q, VariableSentence* v,
TruthValueSentence* s):
quantifier(q), variable(v), sentence(s) {}
string QuantifierSentence::toString() const {
string s;
switch (quantifier) {
case FORALL:
s += "For all ";
s += variable->toString();
s += ", (";
s += sentence->toString();
s += ")";
break;
case EXISTS:
s += "Exists ";
s += variable->toString();
s += ", (";
s += sentence->toString();
s += ")";
break;
}
return s;
}
int QuantifierSentence::getQuantifier() const {
return quantifier;
}
const VariableSentence* QuantifierSentence::getVariable() const {
return variable;
}
const TruthValueSentence* QuantifierSentence::getSentence() const {
return sentence;
}
bool QuantifierSentence::equals(const Sentence* s) const {
const QuantifierSentence* qs;
if ((qs = dynamic_cast<const QuantifierSentence*>(s))) {
if ((*variable == *qs->variable) &&
(*sentence == *qs->sentence))
return true;
}
return false;
}
pair<bool, ConstantSentence*> QuantifierSentence::equalsUpToSubstitution(const
Sentence* s, const VariableSentence* v) const {
const QuantifierSentence* qs;
if ((qs = dynamic_cast<const QuantifierSentence*>(s))) {
return sentence->equalsUpToSubstitution(qs->sentence, v);
}
return pair<bool, ConstantSentence*>(false, 0);
}
QuantifierSentence* QuantifierSentence::clone(const VariableSentence* v, const
ConstantSentence* c) const {
return new QuantifierSentence(quantifier, variable, sentence->clone(v, c));
}
bool QuantifierSentence::containsConstant(const ConstantSentence* c) const {
return (sentence->containsConstant(c));
}
list<Sentence*>* QuantifierSentence::getAllPossibleSubstitutions(const
ConstantSentence* original, const ConstantSentence* substitute) const {
list<Sentence*>* l = new list<Sentence*>();
list<Sentence*>* s = sentence->getAllPossibleSubstitutions(original,
substitute);
for (list<Sentence*>::iterator it = s->begin(); it != s->end(); it++) {
l->push_back(new QuantifierSentence(quantifier, variable,
dynamic_cast<TruthValueSentence*>(*it)));
}
return l;
}
#include <list>
#include <vector>
#include <utility>
namespace Tools {
template<typename T1, typename T2> std::list<std::pair<T1*, T2*> >*
expoMerge(const std::list<T1*>* first, const std::list<T2*>* second) {
std::list<std::pair<T1*, T2*> >* l = new std::list<std::pair<T1*, T2*> >();
for (std::list<T1*>::const_iterator it1 = first->begin(); it1 !=
first->end(); it1++) {
for (std::list<T2*>::const_iterator it2 = second->begin(); it2 !=
second->end(); it2++) {
l->push_back(std::pair<T1*, T2*>(*it1, *it2));
}
}
return l;
}
template<typename T> inline T* tools_clone(T* t) {
return new T(*t);
}
inline Sentence* tools_clone(Sentence* t) {
return t->clone();
}
// assume n >= 1, and that vector is of appropriate size
template<typename T> std::list<std::vector<T*>*>* expoMerge(int n, const
std::vector<const std::list<T*>*>* input) {
if (n == 1) {
std::list<std::vector<T*>*>* l = new std::list<std::vector<T*>*>();
for (std::list<T*>::const_iterator it = (*input)[0]->begin(); it !=
(*input)[0]->end(); it++) {
std::vector<T*>* v = new vector<T*>();
v->push_back(tools_clone(*it));
l->push_back(v);
}
return l;
}
std::list<std::vector<T*>*>* res = expoMerge<T>(n-1, input);
std::list<std::vector<T*>*>* newRes = new std::list<std::vector<T*>*>();
for (std::list<std::vector<T*>*>::iterator it1 = res->begin(); it1 !=
res->end(); it1++) {
for (std::list<T*>::const_iterator it2 = (*input)[n-1]->begin(); it2 !=
(*input)[n-1]->end(); it2++) {
std::vector<T*>* v = new std::vector<T*>(**it1);
v->push_back(*it2);
newRes->push_back(v);
}
}
return newRes;
}
template<typename T1, typename T2, typename T3> struct Triplet {
typedef T1 first_type;
typedef T2 second_type;
typedef T3 third_type;
T1 first;
T2 second;
T3 third;
Triplet() : first(T1()), second(T2()), third(T3()) { }
Triplet(const T1& x, const T2& y, const T3& c): first(x), second(y),
third(z) {}
template<typename U, typename V, typename W> Triplet(const Triplet<U, V,
W>& p): first(p.first), second(p.second), third(p.third) {}
};
template<typename T1, typename T2, typename T3> inline bool operator==(const
Triplet<T1, T2, T3>& x, const Triplet<T1, T2, T3>& y) {
return x.first == y.first && x.second == y.second && x.third == y.third;
}
};
#include "Interface.h"
#include "Sentence.h"
#include "SentenceTree.h"
#include "Tools.h"
#include <vector>
#include <list>
using namespace std;
list<Sentence*>* makeList() {
return new list<Sentence*>();
}
list<Sentence*>* makeList(Sentence* s1) {
list<Sentence*>* s = makeList();
s->push_back(s1);
return s;
}
list<Sentence*>* makeList(Sentence* s1, Sentence* s2) {
list<Sentence*>* s = makeList(s1);
s->push_back(s2);
return s;
}
list<Sentence*>* makeList(Sentence* s1, Sentence* s2, Sentence* s3) {
list<Sentence*>* s = makeList(s1, s2);
s->push_back(s3);
return s;
}
int main() {
cout << "first point" << endl;
flush(cout);
Sentence* s1 = new QuantifierSentence(QuantifierSentence::FORALL, new
VariableSentence("x"), new OperatorSentence(OperatorSentence::IMPLIES, new
PredicateSentence("P", new VariableSentence("x")), new PredicateSentence("Q",
new VariableSentence("x"))));
Sentence* s2 = new PredicateSentence("Q", new FunctionSentence("f", new
ConstantSentence("a")), new FunctionSentence("f", new ConstantSentence("b")));
Sentence* s3 = new EqualitySentence(new FunctionSentence("g", new
ConstantSentence("a")), new VariableSentence("x"));
Sentence* s4 = new OperatorSentence(OperatorSentence::AND, new
PredicateSentence("P", new ConstantSentence("b")), new PredicateSentence("P",
new ConstantSentence("c")));
SentenceTree *t = new SentenceTree(makeList(s1), new
SentenceTree(makeList(s3, s4)), new SentenceTree(makeList(s2)));
cout << t->toString() << endl;
// Sentence* pavel = new PredicateSentence("P", new VariableSentence("x"),
new ConstantSentence("a"));
// const list<WorldValueSentence*>* l =
dynamic_cast<PredicateSentence*>(pavel)->getParameters();
/* Sentence* s =
Interface::iGetTruthValueSentence(Interface::getNameTable());
cout << s->toString() << endl;
delete s;
*/
cout << "second point" << endl;
flush(cout);
Sentence* s1tag = new QuantifierSentence(QuantifierSentence::FORALL, new
VariableSentence("x"), new OperatorSentence(OperatorSentence::IMPLIES, new
PredicateSentence("P", new VariableSentence("x")), new PredicateSentence("Q",
new VariableSentence("x"))));
cout << "are they equal?" << (*s1tag == *s1) << (*s1 == *s1tag) << endl;
cout << "are THEY equal?" << (*s1 == *s4) << (*s3 == *s2) << endl;
Sentence* s1tagayim = s1->clone();
cout << s1->toString() << endl << s1tag->toString() << endl <<
s1tagayim->toString() << endl;
cout << "are THHTHTHEY equal?" << (*s1 == *s1tagayim) << (*s1tag ==
*s1tagayim) << endl;
Sentence* easyS = new ConstantSentence("a");
list<Sentence*>* l = easyS->getAllPossibleSubstitutions(new
ConstantSentence("a"), new ConstantSentence("b"));
for (list<Sentence*>::const_iterator it = l->begin(); it != l->end(); it++) {
cout << (*it)->toString() << endl;
}
cout << "third point" << endl;
flush(cout);
Sentence* mediumS = new OperatorSentence(OperatorSentence::AND, new
EqualitySentence(new ConstantSentence("a"), new ConstantSentence("b")), new
QuantifierSentence(QuantifierSentence::EXISTS, new VariableSentence("x"), new
EqualitySentence(new VariableSentence("x"), new ConstantSentence("a"))));
l = mediumS->getAllPossibleSubstitutions(new ConstantSentence("a"), new
ConstantSentence("b"));
for (list<Sentence*>::const_iterator it = l->begin(); it != l->end(); it++) {
cout << (*it)->toString() << endl;
}
list<WorldValueSentence*> params1;
params1.push_back(new ConstantSentence("a"));
params1.push_back(new ConstantSentence("b"));
params1.push_back(new VariableSentence("x"));
params1.push_back(new VariableSentence("y"));
list<WorldValueSentence*> params2;
params2.push_back(new FunctionSentence("f", new ConstantSentence("a"), new
ConstantSentence("a")));
params2.push_back(new FunctionSentence("g", ¶ms1));
params2.push_back(new ConstantSentence("a"));
params2.push_back(new FunctionSentence("f", ¶ms1));
params2.push_back(new FunctionSentence("g", ¶ms1));
params2.push_back(new FunctionSentence("g", ¶ms1));
Sentence* hardS = new PredicateSentence("P", ¶ms2);
cout << "hardS is" << hardS->toString() << endl;
l = hardS->getAllPossibleSubstitutions(new ConstantSentence("a"), new
ConstantSentence("b"));
for (list<Sentence*>::const_iterator it = l->begin(); it != l->end(); it++) {
cout << (*it)->toString() << endl;
}
/*
template<typename T> std::list<std::vector<T*> >* expoMerge(int n, const std:\
:vector<const
std::list<T*>*>* input) {
*/
cout << "fourth point" << endl;
flush(cout);
int *a = new int(1);
int *b = new int(2);
int *c = new int(3);
int *d = new int(4);
list<int*>* l1 = new list<int*>();
l1->push_back(a);
l1->push_back(b);
list<int*>* l2 = new list<int*>();
l2->push_back(c);
l2->push_back(d);
cout << "fifth point" << endl;
flush(cout);
vector<const list<int*>*>* v = new vector<const list<int*>*>();
v->push_back(l1);
v->push_back(l2);
cout << "sixth point" << endl;
flush(cout);
list<vector<int*>*>* lres = Tools::expoMerge<int>(2, v);
for (list<vector<int*>*>::iterator myIt = lres->begin(); myIt != lres->end();
myIt++) {
for (vector<int*>::iterator myIt2 = (*myIt)->begin(); myIt2 !=
(*myIt)->end(); myIt2++) {
cout << **myIt2 << " ";
}
cout << "\n";
}
return 0;
}
Other related posts:
- » [mathprog] file update (segfault fix)
