#include "arithexpr.h"
#include <math.h>

// IMPLEMENTATION OF ARITHMETIC EXPRESSIONS

const double pi=3.14159654;

binary_plus::binary_plus(expression* l, expression* r):
   binary_operator_expression(l,r,5) {
}

double binary_plus::evaluate(double* L) const {
   return lhs->evaluate(L) + rhs->evaluate(L);
}

expression* binary_plus::clone() const {
   return new binary_plus(*this);
}

void binary_plus::print(ostream& os ) const {
   lhs->print(os);
   os << '+';
   rhs->print(os);
}

expression* binary_plus::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();
   
   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr = 
         new constant(nlhs->evaluate(0) + nrhs->evaluate(0));
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new binary_plus(nlhs,nrhs);
}

binary_minus::binary_minus(expression* l, expression* r):
   binary_operator_expression(l,r,5) {
}

expression* binary_minus::clone() const {
   return new binary_minus(*this);
}

double binary_minus::evaluate(double* L) const {
   return lhs->evaluate(L) - rhs->evaluate(L);
}

void binary_minus::print(ostream& os ) const {
   lhs->print(os);
   os << '-';
   rhs->print(os);
}

expression* binary_minus::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();
   
   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr = 
         new constant(nlhs->evaluate(0) - nrhs->evaluate(0));
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new binary_minus(nlhs,nrhs);
}

division::division(expression* l, expression* r):
   binary_operator_expression(l,r,15) {
}

expression* division::clone() const {
   return new division(*this);
}

double division::evaluate(double* L) const {
   return lhs->evaluate(L) / rhs->evaluate(L);
}

void division::print(ostream& os ) const {
   lhs->print(os);
   os << '/';
   rhs->print(os);
}

expression* division::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();
   
   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr =  
         new constant(nlhs->evaluate(0) / nrhs->evaluate(0));
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new division(nlhs,nrhs);
}

multiplication::multiplication(expression* l, expression* r):
   binary_operator_expression(l,r,10) {
}

expression* multiplication::clone() const {
   return new multiplication(*this);
}

double multiplication::evaluate(double* L) const {
   return lhs->evaluate(L) * rhs->evaluate(L);
}

void multiplication::print(ostream& os ) const {
   lhs->print(os);
   os << '*';
   rhs->print(os);
}

expression* multiplication::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();
   
   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr =  
         new constant(nlhs->evaluate(0) * nrhs->evaluate(0));
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new multiplication(nlhs,nrhs);
}

unary_minus::unary_minus(expression* e):unary_operator_expression(e) {
}

expression* unary_minus::clone() const {
   return new unary_minus(*this);
}

double unary_minus::evaluate(double* L) const {
   return - operand->evaluate(L);
}

void unary_minus::print(ostream& os) const {
   os << '-';
   operand->print(os);
}

expression* unary_minus::simplify() const {
   expression* nop = operand->simplify();
   
   if (nop->simple()) {
      expression * nexpr =  new constant(- nop->evaluate(0));
      delete nop;
      return nexpr;
   } else return new unary_minus(nop);
}

unary_plus::unary_plus(expression* e):unary_operator_expression(e) {
}

expression* unary_plus::clone() const {
   return new unary_plus(*this);
}

double unary_plus::evaluate(double* L) const {
   return + operand->evaluate(L);
}

void unary_plus::print(ostream& os) const {
   os << '+';
   operand->print(os);
}

expression* unary_plus::simplify() const {
   expression* nop = operand->simplify();
   
   if (nop->simple()) {
      expression * nexpr =  new constant(nop->evaluate(0));
      delete nop;
      return nexpr;
   } else return new unary_plus(nop);
}

sin_function::sin_function(expression* e) {
   arg[0] = e;
   argv = arg;
   argc = 1;
}

expression* sin_function::clone() const {
   return new sin_function(*this);
}

double sin_function::evaluate(double* L) const {
   return sin((pi*arg[0]->evaluate(L))/180.0);
}

void sin_function::print(ostream& os) const {
   os << "sin(";
   argv[0]->print(os);
   os << ')';
}

expression* sin_function::simplify() const {
   expression* narg = arg[0]->simplify();
   
   if (narg->simple()) {
      expression * nexpr =  new constant(sin((pi*narg->evaluate(0))/180));
      delete narg;
      return nexpr;
   } else return new sin_function(narg);
}

cos_function::cos_function(expression* e) {
   arg[0] = e;
   argv = arg;
   argc = 1;
}

expression* cos_function::clone() const {
   return new cos_function(*this);
}

double cos_function::evaluate(double* L) const {
   return cos((pi*arg[0]->evaluate(L))/180);
}

void cos_function::print(ostream& os) const {
   os << "cos(";
   argv[0]->print(os);
   os << ')';
}

expression* cos_function::simplify() const {
   expression* narg = arg[0]->simplify();
   
   if (narg->simple()) {
      expression * nexpr =  new constant(cos((pi*narg->evaluate(0))/180));
      delete narg;
      return nexpr;
   } else return new cos_function(narg);
}

tan_function::tan_function(expression* e) {
   arg[0] = e;
   argv = arg;
   argc = 1;
}
 
expression* tan_function::clone() const {
   return new tan_function(*this);
}

double tan_function::evaluate(double* L) const {
   return tan((pi*arg[0]->evaluate(L))/180.0);
} 

void tan_function::print(ostream& os) const {
   os << "tan(";
   argv[0]->print(os);
   os << ')';
}

expression* tan_function::simplify() const {
   expression* narg = arg[0]->simplify();
   
   if (narg->simple()) {
      expression * nexpr = new constant(tan((pi*narg->evaluate(0))/180.0));
      delete narg;
      return nexpr;
   } else return new tan_function(narg);
}