#include "relexpr.h"

// IMPLEMENTATION OF RELATIONAL EXPRESSIONS

equal_expression::equal_expression(expression* l, expression* r):
   binary_operator_expression(l,r,0) {
}

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

double equal_expression::evaluate(double* L) const {
   return lhs->evaluate(L) == rhs->evaluate(L) ? 1 : -1;
}

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

expression* equal_expression::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();

   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr =
         new constant(nlhs->evaluate(0) == nrhs->evaluate(0) ? 1 : -1);
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new equal_expression(nlhs,nrhs);
}

not_equal_expression::not_equal_expression(expression* l, expression* r):
   binary_operator_expression(l,r,0) {
} 

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

double not_equal_expression::evaluate(double* L) const {
   return lhs->evaluate(L) != rhs->evaluate(L) ? 1 : -1;
}

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

expression* not_equal_expression::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();

   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr =
         new constant(nlhs->evaluate(0) != nrhs->evaluate(0) ? 1 : -1);
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new not_equal_expression(nlhs,nrhs);
}

less_expression::less_expression(expression* l, expression* r):
   binary_operator_expression(l,r,0) {
} 

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

double less_expression::evaluate(double* L) const {
   return lhs->evaluate(L) < rhs->evaluate(L) ? 1 : -1;
}

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

expression* less_expression::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();

   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr =
         new constant(nlhs->evaluate(0) < nrhs->evaluate(0) ? 1 : -1);
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new less_expression(nlhs,nrhs);
}

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

less_or_equal_expression::less_or_equal_expression(expression* l,
    expression* r):
   binary_operator_expression(l,r,0) {
} 

double less_or_equal_expression::evaluate(double* L) const {
   return lhs->evaluate(L) <= rhs->evaluate(L) ? 1 : -1;
}

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

expression* less_or_equal_expression::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();

   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr =
         new constant(nlhs->evaluate(0) <= nrhs->evaluate(0) ? 1 : -1);
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new less_or_equal_expression(nlhs,nrhs);
}

greater_expression::greater_expression(expression* l, expression* r):
   binary_operator_expression(l,r,0) {
} 

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

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

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

expression* greater_expression::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();

   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr =
         new constant(nlhs->evaluate(0) > nrhs->evaluate(0) ? 1 : -1);
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new greater_expression(nlhs,nrhs);
}

greater_or_equal_expression::greater_or_equal_expression(expression* l,
   expression* r):
   binary_operator_expression(l,r,0) {
} 

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

double greater_or_equal_expression::evaluate(double* L) const {
   return lhs->evaluate(L) >= rhs->evaluate(L) ? 1 : -1;
}

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

expression* greater_or_equal_expression::simplify() const {
   expression* nlhs = lhs->simplify(),
             * nrhs = rhs->simplify();

   if (nlhs->simple() && nrhs->simple()) {
      expression * nexpr =
         new constant(nlhs->evaluate(0) >= nrhs->evaluate(0) ? 1 : -1);
      delete nlhs;
      delete nrhs;
      return nexpr;
   } else return new greater_or_equal_expression(nlhs,nrhs);
}

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

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

double negation::evaluate(double* L) const {
   double v = operand->evaluate(L);

   return v>=0 ? -1 : 1;
}

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

expression* negation::simplify() const {
   expression* nop = operand->simplify();

   if (nop->simple()) {
      expression * nexpr =
         new constant(nop->evaluate(0) > 0 ? -1 : 1);
      delete nop;
      return nexpr;
   } else return new negation(nop);
}