//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());
}
