void If::evaluate() {
// empty list = false
// not empty list = true
// Im going to receive 3 arguments, if the first argument is
// true then evaluate and return the second one
// if the first argument is false (empty list) the evaluate and
// return the third one
std::vector<Expression*> myArguments = getArguments();
std::vector<Expression*>::iterator it = myArguments.begin();
Expression* condition = *it;
++it;
Expression* trueReturn = *it;
++it;
Expression* falseReturn = *it;
// Start checking conditons
condition->evaluate();
if (condition->getResult() == LISP_FALSE){
falseReturn->evaluate();
result = falseReturn->getResult();
} else {
trueReturn->evaluate();
result = trueReturn->getResult();
}
}
int main()
{
const int SIZE = 256;
Expression* expression;
char paren, comma, line[SIZE];
ifstream fin("input.txt");
while (true)
{
symbolTable.init();
fin.getline(line, SIZE);
if (!fin) break;
stringstream in(line, ios_base::in);
in >> paren;
cout << line << " ";
try
{
expression = SubExpression::parse(in);
in >> comma;
parseAssignments(in);
cout << "Value = " << expression->evaluate() << endl;
}
catch (exception) {
return EXIT_FAILURE;
}
}
return 0;
}
int main(int argc, char** argv) {
ifstream inFile;
char inputFilename[] = "F:\\Documents\\project2input.txt";
inFile.open(inputFilename, ios::in);
if (!inFile) {
cerr << "Can't open input file " << inputFilename << endl;
exit(1);
}
Expression* expression;
std::string token;
std::istringstream line(token);
char paren, comma;
while(std::getline(inFile, token))
{
std::istringstream line(token);
while(line >> token)
{
std::cout << "Token :" << token << std::endl;
line >> paren;
expression = SubExpression::parse();
line >> comma;
parseAssignments();
}
}
cout << "Value = " << expression->evaluate() << endl;
inFile.close();
return 0;
}
Variable* Variable::getVariable(int depth, vector<Expression>& index, Function* origin)
{
if(index.size() <= 0)
{
return this;
}
if(depth == index.size() || !origin)
{
return this;
}
else
{
if(depth < index.size() && depth >= 0)
{
Expression a = index[depth];
Variable v = a.evaluate(origin);
int i = v.getValuef();
if(i < variables.size() && i >= 0)
{
return variables[i].getVariable(depth+1, index, origin);
}
else
{
return this;
}
}
else
{
return this;
}
}
return this;
}
Element* Function::to_element(ContextProtected& context) {
ExpressionParser parser;
Expression* expression = parser(this->sentence);
Environment* env = expression->evaluate(context);
delete expression;
Element* element = env->get_elements()[0]->clone();
delete env;
return element;
}
bool evaluatePredicate(const Expression& expression)
{
Value result(expression.evaluate());
// foo[3] means foo[position()=3]
if (result.isNumber())
return EqTestOp(EqTestOp::OP_EQ, Function::create(ASCIILiteral("position")), std::make_unique<Number>(result.toNumber())).evaluate().toBoolean();
return result.toBoolean();
}
virtual bool evaluate()
{
switch(_operator)
{
case LESS:
return _left->value() < _right->value();
case MORE:
return _left->value() > _right->value();
case EQUAL:
return fabs(_left->value() - _right->value()) <= 0.000001;
case AND:
return _left->evaluate() && _right->evaluate();
case OR:
return _left->evaluate() || _right->evaluate();
default:
throw "Unknown operator";
}
}
int main( int, char*[] )
{
std::string code = "(test 42 ( - 44 ( + 1 1 ) ) ) ";
Compiler compiler(code);
Expression* program = compiler.compile();
printValue( program->evaluate() );
std::cout << std::endl << " ---DONE--- " << std::endl;
}
int main()
{
Expression* expression;
char paren, comma;
cout << "Enter expression: ";
cin >> paren;
expression = SubExpression::parse();
cin >> comma;
parseAssignments();
cout << "Value = " << expression->evaluate() << endl;
return 0;
}
virtual bool evaluate(SimpleCpcClient* c, const SimpleCpcClient::Process & p){
bool run = on_empty;
for(size_t i = 0; i<m_cond.size(); i++){
if(m_cond[i]->evaluate(c, p)){
run = true;
break;
}
}
if(run)
return m_rule->evaluate(c, p);
return false;
}
Number Application::calculate(const std::string &input, int precision) const
{
// tokenizujemy
Tokenizer tok(input);
std::vector<Token*> tokens = tok.tokenize();
Expression *expr = 0;
try {
// sprawdzamy sens
SyntaxChecker checker(tokens);
checker.check();
// parser
Parser parser(tokens, m_precedence);
expr = parser.parse();
} catch (...) {
// usuwanie tokenów
for (Token *tok : tokens) {
delete tok;
}
throw;
}
// rekurencyjnie liczymy rozwiązanie
Number out;
try {
out = expr->evaluate(0, precision);
} catch (...) {
// usuwanie wyrażeń
delete expr;
// usuwanie tokenów
for (Token *tok : tokens) {
delete tok;
}
throw;
}
// usuwanie wyrażeń
delete expr;
// usuwanie tokenów
for (Token *tok : tokens) {
delete tok;
}
return out;
}
void processCell(Expression &expr, double x, double y, double xLen, double yLen, std::vector<sf::Vertex> &Curve) {
double a, b, c, d;
a = expr.evaluate(x, -y);
b = expr.evaluate(x + xLen, -y);
c = expr.evaluate(x + xLen, -y - yLen);
d = expr.evaluate(x, -y - yLen);
int num = ((a > 0.0) ? 1 : 0) + ((b > 0.0) ? 2 : 0) + ((c < 0.0) ? 4 : 0) + ((d > 0.0) ? 8 : 0);
switch(num) {
case 1: case 2: case 4: case 7: case 8: case 11: case 13: case 14: case 3: case 6: case 12: case 9:
draw(num, x, y, xLen, yLen, a, b, c, d, Curve);
// std::cout<<"["<<x<<","<<y<<","<<num<<"]\t";
break;
case 5: case 10:
std::cout << "Recursion Happens\n";
processCell(expr, x, y, xLen / 2, yLen / 2, Curve);
processCell(expr, x + xLen / 2, y, xLen / 2, yLen / 2, Curve);
processCell(expr, x + xLen / 2, y + yLen / 2, xLen / 2, yLen / 2, Curve);
processCell(expr, x, y + xLen / 2, xLen / 2, yLen / 2, Curve);
break;
case 0: case 15:
break;
}
}
/* performs and outputs the choice expression in the output style */
void runSilent(std::string choice,std::string strExpr,std::string output) {
Expression::Notation notation = Expression::NOTATION_INFIX;
Expression* expression = NULL;
bool isValidSelection = true;
if(choice == "infix"){
notation = Expression::NOTATION_INFIX;
}
else if(choice == "postfix"){
notation = Expression::NOTATION_POSTFIX;
}
else if(choice == "prefix"){
notation = Expression::NOTATION_PREFIX;
}
else{
isValidSelection = false;
}
if(isValidSelection){
expression = new Expression(strExpr,notation);
if(!expression->hasError()){
if(output == "infix")
cout << expression->getInfix() << endl;
else if(output == "postfix")
cout << expression->getPostfix() << endl;
else if(output == "prefix")
cout << expression->getPrefix() << endl;
else if(output == "value"){
try{
cout << expression->evaluate() << endl;
}
catch (runtime_error& e)
{
cout << e.what() << endl;
}
}
else
cout << "invalid output format." << endl;
}
else{
cout << expression->getError() << endl;
}
}
else{
cout << "The selection you entered was not valid." << endl;
}
delete expression;
}
int
for_each(Vector<SimpleCpcClient*>& list, Expression & expr){
for(size_t i = 0; i<list.size(); i++){
if(list[i] == 0)
continue;
Properties p;
Vector<SimpleCpcClient::Process> procs;
if(list[i]->list_processes(procs, p) != 0){
ndbout << "Failed to list processes on "
<< list[i]->getHost() << ":" << list[i]->getPort() << endl;
}
for(size_t j = 0; j<procs.size(); j++)
expr.evaluate(list[i], procs[j]);
}
return 0;
}
int main()
{
Tokenizer t;
//adding the tokens for the tokenizer
t.add("\\+|-",PLUSMINUS);
t.add("\\*|/",MULTDIV);
t.add("\\^",RAISED);
t.add("!",FACULTY);
//regexp matching is greedy; try sinh/cosh/tanh first
t.add("sinh|cosh|tanh",FUNCTION);
t.add("asin|acos|atan",FUNCTION);
t.add("sin|cos|tan|sqrt",FUNCTION);
t.add("log\\[[[[:digit:]]+(\\.)?[[:digit:]]*\\]|log",FUNCTION);
t.add("\\(",OPEN_BRACKET);
t.add("\\)",CLOSE_BRACKET);
t.add("[[:digit:]]+(\\.)?[[:digit:]]*",NUMBER);
string str;
while(1) {
cout << "=> ";
if(!getline(cin,str)) {
cout << endl;
return 1;
}
str.erase(remove_if(str.begin(),str.end(), ::isspace),str.end());
if(str.empty())
continue;
if(str == "quit")
break;
try{
vector<token> a = t.tokenize(str);
Parser p(a);
Expression* exp = p.parse();
cout << "\t\t== " << exp->evaluate() << endl;;
} catch (runtime_error& e) {
cout << "\t\tSyntax error: " << e.what() << endl;;
}
}
return 0;
}
int evaluate_file(char *filename) {
ifstream file;
Expression* expression;
file.open(filename, ifstream::in);
try {
file >> &expression;
expression->evaluate( Environment::globalEnvironment );
}
catch (SchemerException *e) {
cerr << "Error in file " << filename << ": " << e << endl;
cerr << "aborting." << endl;
delete e;
}
return 0;
}
int eval_print_loop() {
stringstream stream (stringstream::in | stringstream::out);
string line;
Expression* expression;
while (true) {
stream.clear();
cout << ">>> ";
getline( cin, line );
stream << line;
stream.flush();
/* if end of user input: exit */
if (cin.eof()) {
break;
}
try {
expression = NULL;
stream >> &expression;
if (expression != NULL) {
cout << "=> " << expression->evaluate( Environment::globalEnvironment ) << endl;
}
}
catch (SchemerException *e) {
cerr << "Error: " << e << endl;
delete e;
}
gc_run( Environment::globalEnvironment );
}
cout << endl;
return 0;
}
int main() {
Expression* expression;
char paren, comma, line[maxLineSize];
// Open file for reading.
ifstream input(inputFileName);
while(true) {
input.getline(line, maxLineSize); // Fetch next line until we hit EOF
if(!input) // If no more lines are found get out of the while loop.
break;
strstream in(line, maxLineSize);
cout << line << " "; // Display the current line we are working with
in >> paren; // Get rid of a parenthesis
symbolTable.init(); // Clears all data in our symbol table.
try { // Run the evaluation algorthim and catch/report any errors we detect.
expression = SubExpression::parse(in);
in >> comma;
if(comma != ';') // No variables in this one.
if(comma == ',') // Check to make sure we have a comma if we
parseAssignments(in);
else
throw exception("Error: Syntax Error"); // There was no comma or semi-colon.
double result = expression->evaluate();
cout << "Value= " << result << endl;
} catch(exception& mesg) {
cout << mesg.what() << endl;
}
}
// Keep window open until you press a key.
cout << endl << "Execution complete: Press any key to exit";
cin.get();
return 0;
}
double Expression::readToken(std::map<char, double>& substitutions, std::istream& in)
{
char ch;
eatwhite(in); // Skip whitespace
in.get(ch);
if ( isalpha(ch) )
return substitutions[ch]; // Substitute a variable
else if ( ch == '$' )
{
// Evaluate a subexpression
Expression sub = local_subs.front();
local_subs.pop_front();
return sub.evaluate(substitutions);
}
else if ( isdigit(ch) || ch == '.' )
{
// Read a number
in.putback(ch);
double num;
in >> num;
return num;
}
int main() { // The main function
string exp = ""; // initialize string
while (exp != "#") {
cout << "Please enter an expression: "; // print
getline(cin, exp); // exp is the input entered
if (exp.size() >= 3) { // An expression must be >= to 3 in length
exp = RemoveSpaces(exp); // Remove spaces from the expression string
bool correctInput = CheckInput(exp); // If the input is correct
if (correctInput) { // The input correct
// Add brackets to fix bedmas
exp = Bedmas(exp, 0); // Bedmas for division
exp = Bedmas(exp, 1); // Bedmas for multiplication
exp = Bedmas(exp, 2); // Bedmas for addition
exp = Bedmas(exp, 3); // Bedmas for subtraction
Expression *ex; // Initalize Expression object
ArithmeticExpression *e = new ArithmeticExpression(exp); // Create an object of ArithmeticExpression
e->Split(); // call e’s split, call the recursive tree function
if (!e->error) { // If e’s member variable error is not true
ex = e; // Set an Expression to an ArithmetricExpression to use fields not in Expression
ex->print(); // call ex’s print
printf(" = %.2f\n", atof(ex->evaluate().c_str())); // print the rounded answer
delete e; // Delete the ArithemeticExpression pointer
}
}
else {
cout << "Expression is not well formed" << endl; // print expression
}
}
else {
if (exp != "#") // if the expr is not #
cout << "Expression is not well formed" << endl; // error message
}
cout << endl; // new line
}
return 0; // return 0 to close program
}
int main()
{
map<string, double> externalVars;
MyVariableStorage extVariableStorage(&externalVars);
VariableStorage variableStorage;
variableStorage.setExternalStorage(&extVariableStorage);
cout << "libNumHop example executable!" << endl;
externalVars.insert(pair<string,double>("dog", 55));
externalVars.insert(pair<string,double>("cat", 66));
std::vector<std::string> expr;
expr.push_back("a=5;a=8;a;");
expr.push_back("a=5;\n a=8\n a;");
expr.push_back("a=1;b=2;c=3;d=a+b*c;d");
expr.push_back("a=1;b=2;2^2;b^2;b^b;2^(1+1);b^(a+a)");
expr.push_back("a=1;b=2;c=3;d=4;a=(3+b)+4^2*c^(2+d)-7*(d-1)");
expr.push_back("a=1;b=2;c=3;d=4;a=(3+b)+4^2*c^(2+d)-7/6/5*(d-1)");
expr.push_back("7/3/4/5");
expr.push_back("7/(3/(4/5))");
expr.push_back("(4/3*14*7/3/4/5*5/(4*3/2))");
expr.push_back(" \t # \n a=5;\n # a=8\n a+1; \r\n a+2 \r a+3 \r\n #Some comment ");
expr.push_back("a=1; b=2; a-b; a-b+a");
expr.push_back("a=1; b=2; -a+b; b-a; (-a)+b; b+(-a); ; b+(+a); b+a; +a+b");
expr.push_back("a=1;b=2;c=3;d=4; a-b+c-d+a; a-b-c-d+a");
expr.push_back("1-2*3-3*4-4*5;");
expr.push_back("1-(-2-3-(-4-5))");
expr.push_back("dog=4; 1-(-2-3-(-dog-5))");
expr.push_back("-dog");
expr.push_back("a=1;b=2;-(a-b)");
expr.push_back("2e-2-1E-2; 1e+2+3E+2; 1e2+1E2");
expr.push_back("value=5; value+2; value-2; value*1e+2");
expr.push_back("cat \n dog \r dog=5;cat=2;a=3;b=dog*cat*a;b");
expr.push_back("-1-2-3*4-4-3");
expr.push_back("-1-(2-3)*4-4-3");
expr.push_back("-(((-2-2)-3)*4)");
expr.push_back("2--3; 1+-3; 1-+3; 1++3; 1---3");
expr.push_back("2<3; 2<2; 4.2>2.5; (-4.2)>3; -4.2>3");
expr.push_back("1|0; 0|0; 0|0|0|1; 1|1|1|1|1; 2|3|0; (-2)|3; (-1)|(-2) ");
expr.push_back("1&0; 0&0; (-1)&1.5; 1&1; 1&1&1&0.4; 1&0&1");
expr.push_back("2<3|4<2; 2<3&4<2; 2<3&4>2; x=2.5; (x>2&x<3)*1+(x>3&x<4)*2; x=3.6; (x>2&x<3)*1+(x>3&x<4)*2; ");
expr.push_back("#The following will (should) not work!\n 2*-2; a += 5; 1+1-; = 5; 0.5huj");
for (size_t i=0; i<expr.size(); ++i)
{
cout << endl;
cout << expr[i] << endl;
cout << "----------------------------------------------------------------" << endl;
list<string> exprlist;
extractExpressionRows(expr[i], '#', exprlist);
for (list<string>::iterator it = exprlist.begin(); it!=exprlist.end(); ++it)
{
Expression e;
bool interpretOK = interpretExpressionStringRecursive(*it, e);
if (interpretOK)
{
bool evalOK;
double value = e.evaluate(variableStorage, evalOK);
double value2 = e.evaluate(variableStorage, evalOK); // evaluate again, should give same result
cout << "Evaluating: ";
if (evalOK)
{
cout << "OK : ";
}
else
{
cout << "FAILED: ";
}
cout << e.print() << "\t\t Value: " << value << " " << value2 << endl;
}
else
{
cout << "Interpreting FAILED: " << *it << endl;
}
}
cout << "----------------------------------------------------------------" << endl;
}
return 0;
}
// test function for expressions
int main() {
ProductExpression *expression =
new ProductExpression(
new PowerExpression(
new ConstantExpression( 5 ),
new ConstantExpression( 6 ) ),
new NegateExpression(
new SinExpression(
new ConstantExpression( 19 ) ) ) );
InvertExpression *invExpression = new InvertExpression( expression );
SumExpression *sumExpression = new SumExpression(
invExpression, new ConstantExpression( 2 ) );
sumExpression->print();
printf( "\n" );
printf( "%f\n", sumExpression->evaluate() );
printf( "Writing to file.\n" );
char **pathSteps = new char*[2];
pathSteps[0] = new char[10];
pathSteps[1] = new char[10];
sprintf( pathSteps[0], "test" );
sprintf( pathSteps[1], "file" );
int *stepLength = new int[2];
stepLength[0] = 4;
stepLength[1] = 4;
Path *path = new Path( pathSteps, 2, stepLength, false );
File *file = new File( path, "test.out", 8 );
FileOutputStream *outStream = new FileOutputStream( file, false );
char *error = outStream->getLastError();
if( error != NULL ) {
printf( "Error: %s\n", error );
delete error;
}
ExpressionSerializer::serializeExpression( sumExpression, outStream );
delete outStream;
delete file;
printf( "Reading back in from file.\n" );
pathSteps = new char*[2];
pathSteps[0] = new char[10];
pathSteps[1] = new char[10];
sprintf( pathSteps[0], "test" );
sprintf( pathSteps[1], "file" );
stepLength = new int[2];
stepLength[0] = 4;
stepLength[1] = 4;
path = new Path( pathSteps, 2, stepLength, false );
file = new File( path, "test.out", 8 );
FileInputStream *inStream = new FileInputStream( file );
error = inStream->getLastError();
if( error != NULL ) {
printf( "Error: %s\n", error );
delete error;
}
Expression *readExpression;
ExpressionSerializer::deserializeExpression( &readExpression,
inStream );
delete inStream;
delete file;
readExpression->print();
printf( "\n" );
printf( "%f\n", readExpression->evaluate() );
delete sumExpression;
delete readExpression;
return 0;
}
CAssemblerCommand* parseDirectiveConditional(Parser& parser, int flags)
{
ConditionType type;
std::wstring name;
Expression exp;
const Token& start = parser.peekToken();
ConditionalResult condResult = ConditionalResult::Unknown;
switch (flags)
{
case DIRECTIVE_COND_IF:
type = ConditionType::IF;
exp = parser.parseExpression();
if (exp.isLoaded() == false)
{
parser.printError(start,L"Invalid condition");
return new DummyCommand();
}
if (exp.isConstExpression())
{
ExpressionValue result = exp.evaluate();
if (result.isInt())
condResult = result.intValue != 0 ? ConditionalResult::True : ConditionalResult::False;
}
break;
case DIRECTIVE_COND_IFDEF:
type = ConditionType::IFDEF;
if (parser.parseIdentifier(name) == false)
return nullptr;
break;
case DIRECTIVE_COND_IFNDEF:
type = ConditionType::IFNDEF;
if (parser.parseIdentifier(name) == false)
return nullptr;
break;
}
parser.pushConditionalResult(condResult);
CAssemblerCommand* ifBlock = parser.parseCommandSequence(L'.', {L".else", L".elseif", L".elseifdef", L".elseifndef", L".endif"});
parser.popConditionalResult();
// update the file info so that else commands get the right line number
parser.updateFileInfo();
CAssemblerCommand* elseBlock = nullptr;
const Token &next = parser.nextToken();
const std::wstring stringValue = next.getStringValue();
if (stringValue == L".else")
{
ConditionalResult elseResult = condResult;
switch (condResult)
{
case ConditionalResult::True:
elseResult = ConditionalResult::False;
break;
case ConditionalResult::False:
elseResult = ConditionalResult::True;
break;
}
parser.pushConditionalResult(elseResult);
elseBlock = parser.parseCommandSequence(L'.', {L".endif"});
parser.popConditionalResult();
parser.eatToken(); // eat .endif
} else if (stringValue == L".elseif")
{
elseBlock = parseDirectiveConditional(parser,DIRECTIVE_COND_IF);
} else if (stringValue == L".elseifdef")
{
elseBlock = parseDirectiveConditional(parser,DIRECTIVE_COND_IFDEF);
} else if (stringValue == L".elseifndef")
{
elseBlock = parseDirectiveConditional(parser,DIRECTIVE_COND_IFNDEF);
} else if (stringValue != L".endif")
{
return nullptr;
}
// for true or false blocks, there's no need to create a conditional command
if (condResult == ConditionalResult::True)
{
delete elseBlock;
return ifBlock;
}
if (condResult == ConditionalResult::False)
{
delete ifBlock;
if (elseBlock != nullptr)
return elseBlock;
else
return new DummyCommand();
}
CDirectiveConditional* cond;
if (exp.isLoaded())
cond = new CDirectiveConditional(type,exp);
else if (name.size() != 0)
cond = new CDirectiveConditional(type,name);
else
cond = new CDirectiveConditional(type);
cond->setContent(ifBlock,elseBlock);
return cond;
}
int main() {
std::cout
<< "Démonstration de ValueModel et des opérateurs Unaires / Binaires"
<< std::endl;
ValueModel<double> val(0.8);
ValueModel<double>* val_ptr;
cout << val.evaluate() << " et après modification : ";
val_ptr = &val;
val_ptr->setValue(0.7);
cout << val_ptr->evaluate() << endl;
ValueModel<double> val2(0.9);
ValueModel<double>* val_ptr2 = 0;
val_ptr2 = &val2;
val_ptr2->setValue(0.5);
//cout<<val_ptr2->evaluate()<< endl;
fuzzy::NotMinus1<double> opNot;
fuzzy::AndMin<double> opAnd;
fuzzy::OrMax<double> opOr;
fuzzy::ThenMin<double> opThen;
fuzzy::AggMax<double> opAgg;
fuzzy::CogDefuzz<double> opDefuzz(0, 25, 1);
UnaryExpressionModel<double>* unary_ptr = 0;
UnaryExpressionModel<double> uem(&opNot, val_ptr);
unary_ptr = &uem;
UnaryShadowExpression<double> usem(unary_ptr);
cout << "Démonstration de l'UnaryShadowExpression avec l'opérateur Not : "
<< usem.getTarget()->evaluate(unary_ptr) << endl;
cout << unary_ptr->GetOperator()->evaluate(val_ptr) << endl;
BinaryExpressionModel<double>* binary_ptr;
BinaryExpressionModel<double> bem(&opAnd, val_ptr, val_ptr2);
binary_ptr = &bem;
BinaryShadowExpression<double> bsem(binary_ptr);
cout
<< "Démonstration de la BinaryShadowExpression avec l'opérateur AndMin : "
<< binary_ptr->GetLeft()->evaluate() << " "
<< binary_ptr->GetRight()->evaluate() << endl;
cout << bsem.getTarget()->evaluate(val_ptr, val_ptr2) << endl;
binary_ptr->SetOperator(&opDefuzz);
cout
<< "Démonstration de la BinaryShadowExpression avec l'opérateur Défuzz: "
<< binary_ptr->GetOperator()->evaluate(val_ptr, val_ptr2) << endl;
//final test
//operators
/*
fuzzy::NotMinus1<double> opNot;
fuzzy::AndMin<double> opAnd;
fuzzy::OrMax<double> opOr;
fuzzy::ThenMin<double> opThen;
fuzzy::AggMax<double> opAgg;
fuzzy::CogDefuzz<double> opDefuzz(0, 25, 1);
*/
//fuzzy expression factory
fuzzy::FuzzyFactory<double> f(&opNot, &opAnd, &opOr, &opThen, &opAgg,
&opDefuzz);
//membership function
fuzzy::isTriangle<double> poor(-5, 0, 5);
fuzzy::isTriangle<double> good(0, 5, 10);
fuzzy::isTriangle<double> excellent(5, 10, 15);
fuzzy::isTriangle<double> cheap(0, 5, 10);
fuzzy::isTriangle<double> average(10, 15, 20);
fuzzy::isTriangle<double> generous(20, 25, 30);
//unary_ptr->SetOperator(&poor);
//cout <<"test unary" << unary_ptr->GetOperator()->evaluate(val_ptr) << endl;
//values
ValueModel<double> service(0);
ValueModel<double> food(0);
ValueModel<double> tips(0);
ValueModel<double>* val_ptrs;
ValueModel<double>* val_ptrf;
ValueModel<double>* val_ptrt;
val_ptrs = &service;
val_ptrf = &food;
val_ptrt = &tips;
//fuzzy::SugenoThen<double> sugeno;
//fuzzy::SugenoConclusion<double> sugenoC;
// fuzzy::SugenoDefuzz<double> sugenoD;
//NaryExpressionModel<double>();
//f.NewIs(&tips, &cheap);
Expression<double> *r = f.newAgg(
f.newAgg(
f.newThen(f.newIs(val_ptrs, &poor),
f.newIs(val_ptrt, &cheap)),
f.newThen(f.newIs(val_ptrs, &good),
f.newIs(val_ptrt, &average))),
f.newThen(f.newIs(val_ptrs, &excellent),
f.newIs(val_ptrt, &generous)));
//defuzzification
Expression<double>* system = f.newDefuzz(val_ptrt, r, 0, 25, 1);
//apply input
float s;
std::cout<< endl<<endl<<"Démonstration de l'application ( calcul de pourboire) de l'exemple du cours" << std::endl;
//while (true) {
cout << "service : ";
cin >> s;
val_ptrs->setValue(s);
cout << "tips -> " << system->evaluate() << endl;
//};
std::cout << endl << endl << "Démonstration de Sugeno conclusion : "
<< std::endl;
// Test sur SugenoConclusion
std::vector<double> _coeff(3);
cout << "Coeff 1 :";
cin >> _coeff[0];
cout << "Coeff 2 :";
cin >> _coeff[1];
cout << "Coeff 3 :";
cin >> _coeff[2];
for (int i = 0; i < 3; i++) {
std::cout << _coeff[i] << std::endl;
}
core::ValueModel<double> test1(1);
core::ValueModel<double> test2(2);
core::ValueModel<double> test3(5);
fuzzy::SugenoConclusion<double> sugConc(&_coeff);
std::vector<core::Expression<double>*> tabExp;
tabExp.push_back(&test1);
tabExp.push_back(&test2);
tabExp.push_back(&test3);
for (int i = 0; i < 3; i++) {
std::cout << tabExp.at(i) << std::endl;
}
//sugConc.evaluate(&tabExp);
std::cout << "Sugeno Conclusion : " << sugConc.evaluate(&tabExp)
<< std::endl;
//SugenoDefuzz et donc sur SugenoThen
fuzzy::SugenoThen<double> sugThen;
std::cout << "Sugeno Then : " << sugThen.evaluate(&test3, &test2)
<< std::endl;
std::cout << "Premise Value " << sugThen.getPremiseValue() << std::endl;
// fuzzy::SugenoDefuzz<double> sugDef;
// std::cout << "Sugeno Defuzz : " << sugDef.evaluate(&tabExp) << std::endl;
//Test
std::cout << endl << endl
<< "Démonstration de l'application pour le calcul de la qualité d'un restaurant "
<< std::endl;
fuzzy::isTriangle<double> badQuality(-5, 0, 5);
fuzzy::isTriangle<double> averageQuality(5, 10, 15);
fuzzy::isTriangle<double> excellentQuality(15, 20, 25);
Expression<double> *r1 = f.newAgg(
f.newAgg(
f.newThen(f.newIs(val_ptrs, &poor),
f.newIs(val_ptrf, &badQuality)),
f.newThen(f.newIs(val_ptrs, &good),
f.newIs(val_ptrf, &averageQuality))),
f.newThen(f.newIs(val_ptrs, &excellent),
f.newIs(val_ptrf, &excellentQuality)));
Expression<double>* system1 = f.newDefuzz(val_ptrf, r1, 0, 25, 1);
float fo;
float result, result2;
float savFood, savServ;
std::cout<<"L'univers de définition est de -4.99 à 5 pour les valeurs à saisir " << std::endl;
while (true) {
cout << "qualité du repas : "******"tips -> " << system1->evaluate() << endl;
cout << "service : ";
cin >> s;
if (s == 5) {
s = 4.999;
}
if (s == 0) {
s = 0.00001;
}
val_ptrs->setValue(s);
savServ = system->evaluate();
//cout << "tips -> " << system->evaluate() << endl;
result = savServ + savFood;
result2 = savServ / 2 + savFood;
if (fo >= s) {
if (result >= 23) {
std::cout << "C'est un très bon restaurant" << std::endl;
} else {
if (result >= 20) {
std::cout << "C'est un bon restaurant" << std::endl;
} else {
if (result >= 16) {
std::cout << "C'est un restaurant convenable"
<< std::endl;
} else {
std::cout << "C'est un mauvais restaurant" << std::endl;
}
}
}
} else {
if (result2 >= 16.5) {
std::cout << "C'est un très bon restaurant" << std::endl;
} else {
if (result2 >= 14) {
std::cout << "C'est un bon restaurant" << std::endl;
} else {
std::cout << "C'est un mauvais restaurant" << std::endl;
}
}
}
}
return 0;
}
QVariant Engine::evaluate(Expression ex)
{
return ex.evaluate();
}
/*
Ask the user what type of expression
Let the user enter an expression
Display the conversions and value, or an error
*/
void runNormal(){
string choice;
string expressionStr;
Expression *expression = NULL;
Expression::Notation notation = Expression::NOTATION_INFIX;
bool isValidSelection = true;
cout << "Select the notation of your expression:" << endl;
cout << "1) Infix (Traditional)." << endl;
cout << "2) Postfix (Reverse Polish)." << endl;
cout << "3) Prefix (Polish)." << endl;
cout << endl;
getline(cin,choice);
cout <<endl;
if(choice == "1" || choice == "infix" || choice == "Infix"){
notation = Expression::NOTATION_INFIX;
}
else if(choice == "2" || choice == "postfix" || choice == "Postfix"){
notation = Expression::NOTATION_POSTFIX;
}
else if(choice == "3" || choice == "prefix" || choice == "Prefix"){
notation = Expression::NOTATION_PREFIX;
}
else{
isValidSelection = false;
}
if(isValidSelection){
if(notation == Expression::NOTATION_INFIX){
cout << "Enter your expression in infix notation:" << endl;
}
else if(notation == Expression::NOTATION_POSTFIX){
cout << "Enter your expression in postfix notation:" << endl;
}
else if(notation == Expression::NOTATION_PREFIX){
cout << "Enter your expression in prefix notation:" << endl;
}
getline(cin,expressionStr);
cout << endl;
expression = new Expression(expressionStr,notation);
if(!expression->hasError()){
string outputType = "infix";
if(notation == Expression::NOTATION_INFIX)
{
cout <<
"Would you like to convert to prefix or postfix?" << endl;
getline(cin,outputType);
if(outputType != "postfix")
outputType == "prefix";
cout << endl;
}
if(outputType == "infix")
cout << "Infix: " << expression->getInfix() << endl;
else if(outputType == "postfix")
cout << "Postfix: " << expression->getPostfix() << endl;
else
cout << "Prefix: " << expression->getPrefix() << endl;
try{
cout << "Result: " << expression->evaluate() << endl;
}
catch (runtime_error& e)
{
cout << e.what() << endl;
}
}
else{
cout << "There was a problem ";
cout << "with the expression you entered:" << endl;
cout << expression->getError() << endl;
}
}
else{
cout << "The selection you entered was not valid." << endl;
}
delete expression;
}
/*
* Esplora lo spazio di ricerca per provare tutte le sostituzioni
* possibili di variabili. Quando ha trovato una sostituzione valida
* prova a valutare la regola, se e` soddisfatta la potremo aggiungere
* al conflict set
*/
list<RuleApplication>
RuleSet::solve_search_tree(vector<string> *variables, vector<DTArrayItem> *values, Rule *rule, Fact *fact) {
/* L'algoritmo seguito qui consta di due passi principali:
* 1. Creiamo una sorta di cache per i possibili valori che
* le variabili possono assumere (gia` fatto in explode_var_values)
* 2. Esplodiamo l'albero con tutte le possibili combinazioni
* variabile/valore. In realta` qui non utilizziamo un albero
* vero e proprio ma un vettore di tanti elementi quante sono
* i valori che le variabili possono assumere, pero` l'esplorazione
* avviene come se fosse un albero
*/
Expression *expr = rule->get_lhs();
list<RuleApplication> ret;
FuncMemory funcmem;
uint32_t i;
uint32_t attribute_no = values->size();
uint32_t var_no = variables->size();
int32_t pos;
if (variables->size() == 0) {
/* se non ci sono variabili valutiamo la regola direttamente */
if (expr->evaluate(&funcmem, fact)) {
debug(rule->get_name());
RuleApplication r;
r.rule = rule;
r.funcmem = funcmem;
ret.push_back(r);
}
return ret;
}
vector<Variable> resolved_vars;
vector<uint32_t> idx(var_no);
for (i = 0; i < var_no; i++) {
Variable tmp;
tmp.varname = (*variables)[i];
tmp.value = (*values)[0];
resolved_vars.push_back(tmp);
idx[i] = 0;
}
bool resolved = false;
while (!resolved) {
funcmem.clear();
/* costruisci una FuncMemory con i valori puntati dagli indici delle
* variabili. Tale FuncMemory sara` poi quella che verra` usata durante
* la verifica della regola.
*/
pos = var_no;
while (pos-- > 0)
funcmem[resolved_vars[pos].varname] = resolved_vars[pos].value;
if (expr->evaluate(&funcmem, fact)) {
/* la regola e` risultata applicabile, aggiungiamola alla lista di
* applicazioni possibili
*/
debug(rule->get_name());
RuleApplication r;
r.rule = rule;
r.funcmem = funcmem;
ret.push_back(r);
}
/* controlla se abbiamo finito */
for (i = 0; i < var_no; i++) {
resolved = (idx[i] == attribute_no - 1);
if (!resolved) break;
}
if (resolved) break;
/* altrimenti incrementa il contatore degli indici */
increment_idxs(&idx, var_no, attribute_no, &resolved_vars, values);
}
return ret;
};
