//deklarerar Logarithm::Logarithm (const Expression& E_, const double c1_, const double c2_, const int b_) { c1 = c1_; c2 = c2_; b = b_; E = E_.clone(); //klonar polynom til this-objekt }
void Interpreter::setIndex(Instruction* instruction) { enforce(instruction->getOperandAmount() == 1, "set_index need exactly one operand"); Expression* exp = this->resolveExpression(instruction->getOperand(0)); exp->is<NumericExpression>().ensure("Index must be integer"); this->pushStack(exp->clone()); }
Expression * Trigonometry::shallowReduceDirectFunction(Expression * e, Context& context, Expression::AngleUnit angleUnit) { assert(e->type() == Expression::Type::Sine || e->type() == Expression::Type::Cosine || e->type() == Expression::Type::Tangent); Expression * lookup = Trigonometry::table(e->operand(0), e->type(), context, angleUnit); if (lookup != nullptr) { return e->replaceWith(lookup, true); } Expression::Type correspondingType = e->type() == Expression::Type::Cosine ? Expression::Type::ArcCosine : (e->type() == Expression::Type::Sine ? Expression::Type::ArcSine : Expression::Type::ArcTangent); if (e->operand(0)->type() == correspondingType) { float trigoOp = e->operand(0)->operand(0)->approximateToScalar<float>(context, angleUnit); if (e->type() == Expression::Type::Tangent || (trigoOp >= -1.0f && trigoOp <= 1.0f)) { return e->replaceWith(e->editableOperand(0)->editableOperand(0), true); } } if (e->operand(0)->sign() == Expression::Sign::Negative) { Expression * op = e->editableOperand(0); Expression * newOp = op->setSign(Expression::Sign::Positive, context, angleUnit); newOp->shallowReduce(context, angleUnit); if (e->type() == Expression::Type::Cosine) { return e->shallowReduce(context, angleUnit); } else { Multiplication * m = new Multiplication(new Rational(-1), e->clone(), false); m->editableOperand(1)->shallowReduce(context, angleUnit); return e->replaceWith(m, true)->shallowReduce(context, angleUnit); } } if ((angleUnit == Expression::AngleUnit::Radian && e->operand(0)->type() == Expression::Type::Multiplication && e->operand(0)->numberOfOperands() == 2 && e->operand(0)->operand(1)->type() == Expression::Type::Symbol && static_cast<const Symbol *>(e->operand(0)->operand(1))->name() == Ion::Charset::SmallPi && e->operand(0)->operand(0)->type() == Expression::Type::Rational) || (angleUnit == Expression::AngleUnit::Degree && e->operand(0)->type() == Expression::Type::Rational)) { Rational * r = angleUnit == Expression::AngleUnit::Radian ? static_cast<Rational *>(e->editableOperand(0)->editableOperand(0)) : static_cast<Rational *>(e->editableOperand(0)); int unaryCoefficient = 1; // store 1 or -1 // Replace argument in [0, Pi/2[ or [0, 90[ Integer divisor = angleUnit == Expression::AngleUnit::Radian ? r->denominator() : Integer::Multiplication(r->denominator(), Integer(90)); Integer dividand = angleUnit == Expression::AngleUnit::Radian ? Integer::Addition(r->numerator(), r->numerator()) : r->numerator(); if (divisor.isLowerThan(dividand)) { Integer piDivisor = angleUnit == Expression::AngleUnit::Radian ? r->denominator() : Integer::Multiplication(r->denominator(), Integer(180)); IntegerDivision div = Integer::Division(r->numerator(), piDivisor); dividand = angleUnit == Expression::AngleUnit::Radian ? Integer::Addition(div.remainder, div.remainder) : div.remainder; if (divisor.isLowerThan(dividand)) { div.remainder = Integer::Subtraction(piDivisor, div.remainder); if (e->type() == Expression::Type::Cosine || e->type() == Expression::Type::Tangent) { unaryCoefficient *= -1; } } Rational * newR = new Rational(div.remainder, r->denominator()); Expression * rationalParent = angleUnit == Expression::AngleUnit::Radian ? e->editableOperand(0) : e; rationalParent->replaceOperand(r, newR, true); e->editableOperand(0)->shallowReduce(context, angleUnit); if (Integer::Division(div.quotient, Integer(2)).remainder.isOne() && e->type() != Expression::Type::Tangent) { unaryCoefficient *= -1; } Expression * simplifiedCosine = e->shallowReduce(context, angleUnit); // recursive Multiplication * m = new Multiplication(new Rational(unaryCoefficient), simplifiedCosine->clone(), false); return simplifiedCosine->replaceWith(m, true)->shallowReduce(context, angleUnit); } assert(r->sign() == Expression::Sign::Positive); assert(!divisor.isLowerThan(dividand)); } return e; }
void testConstante() { // c = 5 Expression * c = new Constante(5); cout << "c = "<< *c << endl; Expression * cbis = c->clone(); cout << "clone de c = " << *cbis << endl; delete c; delete cbis; }
void Interpreter::fetch(Instruction* instruction) { enforce(instruction->getOperandAmount() == 2, "fetch need exactly two operands"); Expression* exp = this->resolveVariable(instruction->getOperand(0)); Expression* idx = this->resolveExpression(instruction->getOperand(1)); const u32_t index = idx->is<NumericExpression>().ensure("Fetch-Index must be numeric")->getAs<u32_t>(); Expression* val = exp->is<ArrayExpression>().ensure("Need an array to fetch")->fetch(index); this->pushStack(val->clone()); }
void Interpreter::assign(Instruction* instruction) { enforce(instruction->getOperandAmount() == 2, "assign need exactly two operands"); enforce(instruction->getOperand(0)->getType() == OpCode::VARIABLE, "Expected a variable"); const size_t vi = this->getIndexOf(instruction->getOperand(0)); debug("assign variable ", vi); Expression* exp = this->resolveExpression(instruction->getOperand(1)); #if DEBUG ::print(exp); #endif this->assignVariable(vi, exp->clone()); }
void Interpreter::append(Instruction* instruction) { enforce(instruction->getOperandAmount() == 2, "append need exactly two operands"); const size_t vi = this->getIndexOf(instruction->getOperand(0)); Expression* exp = this->fetchVariable(vi); if (!exp) { debug("No variable found, gen a new one"); exp = new ArrayExpression(); this->assignVariable(vi, exp); } Expression* val = this->resolveExpression(instruction->getOperand(1)); #if DEBUG ::print(val); #endif exp->is<ArrayExpression>().ensure("Can only append on an array")->append(val->clone()); }
void testVariable1() { // x = 3 Variable x("x", 3.0); // y = 0 Variable y("y"); cout << x << " = " << x.eval() << endl; cout << y << " = " << y.eval() << endl; // exp = 1 + 2 * x Expression * exp = new Somme(new Constante(1.0), new Produit(new Constante(2.0), &x)); // a = (y <- exp) Affectation * a = new Affectation(new Variable("y"), exp->clone()); cout << *a << " = " << a->eval() << endl; cout << y << " = " << y.eval() << endl; Variable::effacerMemoire(); delete exp; // OK car il existe un clone delete a; cout << "destruction automatique des variables locales allouees sur la PILE: ICI X et Y" << endl; }
virtual AddExpression<T>* clone() const override { return new AddExpression<T>(e1->clone(), e2->clone()); }
Expression* Interpreter::makeExpression(Instruction* instruction) { switch (instruction->getType()) { case Instruction::ADD: { Expression* lhs = this->resolveExpression(instruction->getOperand(0)); Expression* rhs = this->resolveExpression(instruction->getOperand(1)); return new AddExpression(lhs->clone(), rhs->clone()); } case Instruction::SUB: { Expression* lhs = this->resolveExpression(instruction->getOperand(0)); Expression* rhs = this->resolveExpression(instruction->getOperand(1)); return new SubtractExpression(lhs->clone(), rhs->clone()); } case Instruction::MUL: { Expression* lhs = this->resolveExpression(instruction->getOperand(0)); Expression* rhs = this->resolveExpression(instruction->getOperand(1)); return new MultiplyExpression(lhs->clone(), rhs->clone()); } case Instruction::DIV: { Expression* lhs = this->resolveExpression(instruction->getOperand(0)); Expression* rhs = this->resolveExpression(instruction->getOperand(1)); return new DivideExpression(lhs->clone(), rhs->clone()); } case Instruction::MOD: { Expression* lhs = this->resolveExpression(instruction->getOperand(0)); Expression* rhs = this->resolveExpression(instruction->getOperand(1)); return new ModuloExpression(lhs->clone(), rhs->clone()); } case Instruction::NOT: { Expression* val = this->resolveExpression(instruction->getOperand(0)); return new NotExpression(val->clone()); } case Instruction::NEG: { Expression* val = this->resolveExpression(instruction->getOperand(0)); return new NegateExpression(val->clone()); } case Instruction::INC: { Expression* val = this->resolveExpression(instruction->getOperand(0)); return new IncrementExpression(val->clone()); } case Instruction::DEC: { Expression* val = this->resolveExpression(instruction->getOperand(0)); return new DecrementExpression(val->clone()); } default: error("Invalid math expression"); } return nullptr; }
void Interpreter::push(Instruction* instruction) { enforce(instruction->getOperandAmount() == 1, "push need exactly one operand"); Expression* exp = this->resolveExpression(instruction->getOperand(0)); this->pushStack(exp->clone()); }
void Interpreter::emplace(Instruction* instruction) { enforce(instruction->getOperandAmount() == 2, "emplace need exactly two operands"); Expression* exp = this->resolveVariable(instruction->getOperand(0)); Expression* val = this->resolveExpression(instruction->getOperand(1)); auto idx = this->popStack(); const u32_t index = idx->is<NumericExpression>().ensure("Index must be numeric")->getAs<u32_t>(); exp->is<ArrayExpression>().ensure("Need an array for emplace")->emplace(index, val->clone()); }
void add(const Expression &exp) { _exps.push_back(exp.clone()); }