void eval() { if (cond->check(map)) { _then->eval(map); } else { _else->eval(map); } }
int interpret(string code) { TokenList tokens = Lexer(code).tokenize(); Expression * exprTree = Parser(tokens).parse(); int res = exprTree->eval(); delete exprTree; return res; }
// boucle avec plusieurs instructions (un bloc) void testPour2() { // x = 3 Variable * x = new Variable("x", 3.0); cout << *x << " = " << x->eval() << endl; // i = 0 Variable * i = new Variable("i"); cout << *i << " = " << i->eval() << endl; // init = (i = 1) Expression * init = new Affectation(i,new Constante(1.0)); // condition = (4 > i) Expression * condition = new Superieur(new Constante(4), i); // actionFinDeBoucle = (i = i + 1) Expression * actionFinDeBoucle = new Affectation(i, new Somme(i, new Constante(1))); // calcul = { // x = x + 9 // if (x > 20) x = x + 10 else x = x * 10 // y = 3 // y = x + -100 // } // bloc = { // x = x + 9 // } Bloc * bloc = new Bloc("b1", new Affectation(x, new Somme(x, new Constante(9)))); // bloc = { // x = x + 9 // if (x > 20) x = x + 10 else x = x * 10 // y = 3 // y = x + -100 // } bloc->add(new IfThenElse(new Superieur(x, new Constante(20.0)), new Affectation(x, new Somme(x, new Constante(10.0))), new Affectation(x, new Produit(x, new Constante(10.0))))); Variable * y = new Variable("y", 5); bloc->add(new Affectation(y, new Somme(x, new Constante(-100)))); // calcul = { // x = x + 9 // if (x > 20) x = x + 10 else x = x * 10 // y = 3 // y = x + -100 // Expression * calcul(bloc); // pour = for (i = 1; 4 > i; i = i + 1) { // x = x + 9 // if (x > 20) x = x + 10 else x = x * 10 // y = 3 // y = x + -100 // } Expression * pour = new Pour(init, condition, actionFinDeBoucle, calcul); cout << *pour << "\n EVAL pour : " << pour->eval() << endl; cout << *x << " = " << x->eval() << endl; cout << *y << " = " << y->eval() << endl; }
// Calcul d'une factorielle void testPour1() { // x = 3 Variable * x = new Variable("x", 3.0); cout << *x << " = " << x->eval() << endl; // i = 0 Variable * i = new Variable("i"); cout << *i << " = " << i->eval() << endl; // init = (i = 1) Expression * init = new Affectation(i,new Constante(1)); // condition = (x > i - 1) Expression * condition = new Superieur(x, new Somme(i, new Constante(-1))); // actionFinDeBoucle = (i = i + 1) Expression * actionFinDeBoucle = new Affectation(i, new Somme(i, new Constante(1))); // calcul = (res = res * i) Variable * res = new Variable("res", 1); Expression * calcul(new Affectation(res, new Produit(res,i))); // pour = for (i = 1; x > i; i = i + 1) res = res * i Expression * pour = new Pour(init, condition, actionFinDeBoucle, calcul); cout << *pour << "\n EVAL pour : " << pour->eval() << endl; cout << x->eval() <<"!" << " = " << res->eval() << endl; // x = 5 x->set(5.0); cout << *x << " = " << x->eval() << endl; // condition = (x > i - 1) condition = new Superieur(x, new Somme(i, new Constante(-1))); // pour = for (i = 1; x > i; i = i + 1) res = res * i res->set(1); pour = new Pour(init, condition, actionFinDeBoucle, calcul); cout << *pour << "\n EVAL pour : " << pour->eval() << endl; cout << x->eval() <<"!" << " = " << res->eval() << endl; Variable::effacerMemoire(); }
void testBinaire() { // s = 1 + 2 * sin(PI/6) Somme * s = new Somme(new Constante(1.0), new Produit(new Constante(2.0), new Sin(new Constante(M_PI/6.0)))); cout << "s : " << *s << " = " << s->eval() << endl; Expression * sbis = s->clone(); cout << "clone de s : " << *sbis << " = " << sbis->eval() << endl; // s > 1 Superieur comp(s->clone(), new Constante(1.8)); cout << comp << " = " << (bool)comp.eval() << endl; delete s; delete sbis; cout << "destruction automatique des variables locales allouees sur la PILE: ICI COMP" << endl; }
/// SASLThunkTouch Expression* Thunk::touch() { // if we haven't already evaluated, do it now if (!evaluated) { evaluated = 1; Expression* start = value(); if (start) { start->eval(value, valueOps, context); } } Expression* val = value(); if (val) { return val->touch(); } return val; }
//----------------------------------------------------------------------------- void Mesh::init_cell_orientations(const Expression& global_normal) { std::size_t gdim = geometry().dim(); std::size_t ndim = global_normal.value_size(); // Check that global_normal has the "right" size // Allowing 3 if gdim < 3 to avoid breaking legacy code. if (ndim < gdim && ndim <= 3) { dolfin_error("Mesh.cpp", "initialize cell orientations", "Global normal value size is %d, smaller than gdim (%d)", ndim, gdim); } // Resize storage _cell_orientations.resize(num_cells()); // Set orientation Array<double> values(ndim); Point up; for (CellIterator cell(*this); !cell.end(); ++cell) { // Extract cell midpoint as Array const Array<double> x(3, cell->midpoint().coordinates()); // Evaluate global normal at cell midpoint global_normal.eval(values, x); // Extract values as Point for (unsigned int i = 0; i < ndim; i++) up[i] = values[i]; for (unsigned int i = ndim; i < gdim; i++) up[i] = 0.0; // Set orientation as orientation relative to up direction. dolfin_assert(cell->index() < _cell_orientations.size()); _cell_orientations[cell->index()] = cell->orientation(up); } }
virtual T eval(const ExpressionContext<T> &ctx) const override { return e1->eval(ctx) - e2->eval(ctx); }
virtual T eval(const ExpressionContext<T> &ctx) const override { return pow(e1->eval(ctx), e2->eval(ctx)); }
double Block::eval() { Expression * tmp = _expressions.back(); return tmp->eval(); }
void testEval() { Expression * expr = new Multiply(new Number(3), new Multiply(new Number(4), new Number(5))); check("eval", expr->eval() == 60); }
int creation() { string pathExe; cout << "Entrer le path de l'excercice que vous voulez créer (.txt) : "; cin >> pathExe; string pathRes; cout << "Entrer le path du resultat que vous voulez stocker (.txt) : "; cin >> pathRes; ofstream exe; exe.open(pathExe); ofstream res; res.open(pathRes); Expression* e; string s; double d; string question = " = ?"; string result = " = "; int choice = -1; do { viewMenuCreation(); cin >> choice; switch(choice) { case 1: { cout << "\n\t\tA (constante)\n" << endl; e = sConstante(); s = e->afficher(); exe << s << "\n"; d = e->eval(); res << d << "\n"; printContent("", "", d); break; } case 2: { cout << "\n\t\tcos(A)\n" << endl; e = sCos(sConstante()); s = e->afficher(); exe << s << question << "\n"; d = e->eval(); res << s << result << d << "\n"; printContent(s, result, d); break; } case 3: { cout << "\n\t\t(C + (B * sin(A)))\n" << endl; e = sSomme(sConstante(), sProduit(sConstante(), sSin(sConstante()))); s = e->afficher(); exe << s << question << "\n"; d = e->eval(); res << s << result << d << "\n"; printContent(s, result, d); break; } case 4: { cout << "\n\t\t((D + (C * sin(B))) > A) => true(1), false(0)\n" << endl; e = sSuperieur(sSomme(sConstante(), sProduit(sConstante(), sSin(sConstante()))), sConstante()); s = e->afficher(); exe << s << question << "\n"; d = e->eval(); res << s << result << d << "\n"; printContent(s, result, d); break; } case 5: { cout << "\n\t\tx = A\n\t(y <- (C + (B * x))) = ?\n" << endl; Variable *e1; e1 = sVariable(); s = e1->afficher(); d = e1->eval(); exe << s << result << d << "\n"; res << s << result << d << "\n"; printContent(s, result, d); //////////////////////////////////// e = sAffectation(sVariableAChercher(), sSomme(sConstante(), sProduit(sConstante(), e1->clone()))); s = e->afficher(); exe << s << question << "\n"; d = e->eval(); res << s << result << d << "\n"; printContent(s, result, d); break; } case 6: { cout << "\n\t\tx = A\n\t\t((x > D)) ? (x + C) : (x + B)\n\t\t=> EVAL ternaire = ?\n" << endl; Variable *e1; e1 = sVariable(); s = e1->afficher(); d = e1->eval(); exe << s << result << d << "\n"; res << s << result << d << "\n"; //////////////////////////////////// e = sConditionnel(sSuperieur(e1->clone(), sConstante()), sSomme(e1->clone(), sConstante()), sProduit(e1->clone(), sConstante())); s = e->afficher(); exe << s << "\n=> EVAL ternaire" << question << "\n"; d = e->eval(); res << s << "\n=> EVAL ternaire" << result << d << "\n"; printContent(s, "\n=> EVAL ternaire" + result, d); break; } case 7: { cout << "\n\t\tx = A\n\t\tif ((x > D)) {\n\t\t\t(x <- (x + C))\n\t\t} else {\n\t\t\t(x <- (x * B))\n\t\t}\n\t\t=> EVAL if then else = ?\n" << endl; Variable *e1; e1 = sVariable(); s = e1->afficher(); d = e1->eval(); exe << s << result << d << "\n"; res << s << result << d << "\n"; //////////////////////////////////// e = sIfThenElse(sSuperieur(e1->clone(), sConstante()), sAffectation(e1, sSomme(e1->clone(), sConstante())), sAffectation(e1, sProduit(e1->clone(), sConstante()))); s = e->afficher(); exe << s << "\n=> EVAL if then else" << question << "\n"; d = e->eval(); res << s << "\n=> EVAL if then else" << result << d << "\n"; printContent(s, "\n=> EVAL if then else" + result, d); break; } case 8: { cout << "\n\t\tx = A\n\t\ty = B\n\t\t{\n\t\t\t(x <- (x + C))\n\t\t\tif ((x > F)) {\n\t\t\t(x <- (x + E))\n\t\t} else {\n\t\t\t(x <- (x * D))\n\t\t}\n\t\t\t(y <- (x + G))\n\t\t}\n\t\t=> EVAL bloc = ?\n" << endl; Variable *e1; //x e1 = sVariable(); s = e1->afficher(); d = e1->eval(); exe << s << result << d << "\n"; res << s << result << d << "\n"; /////////////////////////////// Variable *e2; //y e2 = sVariable(); s = e1->afficher(); d = e1->eval(); exe << s << result << d << "\n"; res << s << result << d << "\n"; /////////////////////////////// Bloc* b; b = sBloc("b1", sAffectation(e1, sSomme(e1->clone(), sConstante()))); b->add(sIfThenElse(sSuperieur(e1->clone(), sConstante()), sAffectation(e1, sSomme(e1->clone(), sConstante())), sAffectation(e1, sProduit(e1->clone(), sConstante())))); b->add(sAffectation(e2, sSomme(e1->clone(), sConstante()))); s = b->afficher(); exe << s << "\n=> EVAL bloc" << question << "\n"; d = b->eval(); res << s << "\n=> EVAL bloc" << result << d << "\n"; printContent(s, "\n=> EVAL bloc" + result, d); break; } case 9: { cout << "\n\t\tx = A\n\t\ti = B\n\t\tfor ((i <- E); (x > (i + D)); (i <- (i + C))) {\n\t\t\t(res <- (res * i))\n\t\t}\n\t\t=>EVAL pour = ?\n" << endl; Variable *e1; //x e1 = sVariable(); s = e1->afficher(); d = e1->eval(); exe << s << result << d << "\n"; res << s << result << d << "\n"; /////////////////////////////// Variable *e2; //i e2 = sVariable(); s = e1->afficher(); d = e1->eval(); exe << s << result << d << "\n"; res << s << result << d << "\n"; /////////////////////////////// Variable *e3; //res e3 = new Variable("res", 1); /////////////////////////////// e = sPour(sAffectation(e2, sConstante()), sSuperieur(e1->clone(), sSomme(e2->clone(), sConstante())), sAffectation(e2, sSomme(e2->clone(), sConstante())), sAffectation(e3, sProduit(e3->clone(), e2->clone()))); s = e->afficher(); exe << s << "\n=> EVAL pour" << question << "\n"; d = e->eval(); res << s << "\n=> EVAL pour" << result << d << "\n"; printContent(s, "\n=> EVAL bloc" + result, d); break; } case 0: { s = "******************************************************************\n\n"; exe << s; res << s; break; } case 999: { cout << "Sauvegarder des fichiers et quitter......" << endl; exe.close(); res.close(); break; } default: cout << "Le cas inconnu......" << endl; break; } } while (choice != 999); return 0; }
Variant SimpleFunctionCallExpression::eval(VariableEnvironment &env) const { SET_LINE; String name(m_name->get(env)); String originalName = name; bool renamed = false; // handling closure if (name[0] == '0') { const char *id = strchr(name.data(), ':'); if (id) { int pos = id - name.data(); String sid = name.substr(pos + 1); String function = name.substr(0, pos); const Function *fs = RequestEvalState::findFunction(function.data()); if (fs) { const FunctionStatement *fstmt = dynamic_cast<const FunctionStatement *>(fs); if (fstmt) { ObjectData *closure = (ObjectData*)sid.toInt64(); return ref(fstmt->invokeClosure(Object(closure), env, this)); } } } } else { name = get_renamed_function(name, &renamed); if (name[0] == '\\') { name = name.substr(1); // try namespaced function first renamed = true; } } // fast path for interpreted fn const Function *fs = RequestEvalState::findFunction(name.data()); if (fs) { return ref(fs->directInvoke(env, this)); } if (originalName[0] == '\\') { name = originalName.lastToken('\\'); name = get_renamed_function(name, &renamed); renamed = true; fs = RequestEvalState::findFunction(name.data()); if (fs) { return ref(fs->directInvoke(env, this)); } } const CallInfo *cit1; void *vt1; get_call_info_or_fail(cit1, vt1, name); ArrayInit ai(m_params.size(), true); bool invokeClosure = false; Variant arg0; for (unsigned int i = 0; i < m_params.size(); ++i) { Expression *param = m_params[i].get(); if (i == 0 && (name == "call_user_func" || name == "call_user_func_array")) { ASSERT(!cit1->mustBeRef(i) && !cit1->isRef(i)); arg0 = param->eval(env); if (arg0.instanceof("closure")) { invokeClosure = true; } else { ai.set(arg0); } continue; } if (cit1->mustBeRef(i)) { ai.setRef(param->refval(env)); } else if (cit1->isRef(i)) { ai.setRef(param->refval(env, 0)); } else { ai.set(param->eval(env)); } } if (invokeClosure) { String sfunction = arg0.toString(); const char *id = sfunction.data(); assert(id[0] == '0'); id = strchr(id, ':'); ASSERT(id); int pos = id - sfunction.data(); String sid = sfunction.substr(pos + 1); sfunction = sfunction.substr(0, pos); const Function *fs = RequestEvalState::findFunction(sfunction.data()); const FunctionStatement *fstmt = dynamic_cast<const FunctionStatement *>(fs); ObjectData *closure = (ObjectData*)sid.toInt64(); return ref(fstmt->invokeClosure(Object(closure), env, this)); } return (cit1->getFunc())(vt1, Array(ai.create())); }