Corregidos errores de destructores

1 files changed, 86 insertions, 14 deletions

diff --git a/expressions.cpp b/expressions.cpp
index e402020..722794f 100644
--- a/expressions.cpp
+++ b/expressions.cpp
@@ -1,5 +1,7 @@
 #include <cstddef>
+#include <math.h>
 #include <string>
+#include <cmath>
 #include "include/lexer.hpp"
 #include "include/expressions.hpp"
 
@@ -10,14 +12,16 @@ Literal::Literal(int value) : Expression(NULL, NULL, number) {
   this->value = value;
 }
 
-Literal::~Literal() {
-  delTree();
-}
+Literal::~Literal() {}
 
 void Literal::setRepr() {
   repr = to_string(value);
 }
 
+float Literal::eval(int arg) {
+  return value;
+}
+
 // Function.
 Function::Function(Expression *arg, trig_functions name) : Expression(NULL, NULL, function) {
   this->arg = arg;
@@ -28,36 +32,56 @@ Function::~Function() {
   delTree();
 }
 
-trig_functions Function::getFunctionName() { return function_name; }
+trig_functions Function::getFunctionName() {
+  return function_name;
+}
 
 void Function::delTree() {
   delete arg;
-  delete this;
+}
+
+float Function::eval(int arg) {
+  float function_arg = this->arg->eval(arg);
+  
+  switch(function_name) {
+  case i_sin:
+    return std::sin(function_arg);
+  case i_cos:
+    return std::cos(function_arg);
+  case i_tan:
+    return std::tan(function_arg);
+  case i_csc:
+    return std::asin(function_arg);
+  case i_sec:
+    return std::acos(function_arg);
+  case i_ctg:
+    return std::atan(function_arg);
+  }
 }
 
 void Function::setRepr() {
   switch(function_name) {
-  case sin:
+  case i_sin:
     repr += "sin";
     
     break;
-  case cos:
+  case i_cos:
     repr += "cos";
     
     break;
-  case tan:
+  case i_tan:
     repr += "tan";
     
     break;
-  case csc:
+  case i_csc:
     repr += "csc";
     
     break;
-  case sec:
+  case i_sec:
     repr += "sec";
     
     break;
-  case ctg:
+  case i_ctg:
     repr += "ctg";
     
     break;
@@ -74,14 +98,16 @@ Variable::Variable(char name) : Expression(NULL, NULL, variable) {
   setRepr();
 }
 
-Variable::~Variable() {
-  delTree();
-}
+Variable::~Variable() {}
 
 void Variable::setRepr() {
   repr += name;
 }
 
+float Variable::eval(int arg) {
+  return arg;
+}
+
 // Sum.
 AddExpression::AddExpression(Expression *left, Expression *right)
   : Expression(left, right, sum) {}
@@ -90,6 +116,13 @@ AddExpression::~AddExpression() {
   delTree();
 }
 
+float AddExpression::eval(int arg) {
+  float right_val = right->eval(arg);
+  float left_val = left->eval(arg);
+
+  return right_val + left_val;
+}
+
 // Substraction.
 SubExpression::SubExpression(Expression *left, Expression *right)
   : Expression(left, right, substraction) {}
@@ -98,6 +131,13 @@ SubExpression::~SubExpression() {
   delTree();
 }
 
+float SubExpression::eval(int arg) {
+  float right_val = right->eval(arg);
+  float left_val = left->eval(arg);
+
+  return right_val - left_val;
+}
+
 // Negation.
 NegationExpression::NegationExpression(Expression *right)
   : Expression(NULL, right, substraction) {}
@@ -106,6 +146,17 @@ NegationExpression::~NegationExpression() {
   delTree();
 }
 
+void NegationExpression::setRepr() {
+  repr = "-(";
+  repr += right->getRepr() + ")";
+}
+
+float NegationExpression::eval(int arg) {
+  float expr_value = right->eval(arg);
+
+  return -1 * expr_value;
+}
+
 // División.
 DivisionExpression::DivisionExpression(Expression *left, Expression *right)
   : Expression(left, right, division) {}
@@ -114,6 +165,13 @@ DivisionExpression::~DivisionExpression() {
   delTree();
 }
 
+float DivisionExpression::eval(int arg) {
+  float right_val = right->eval(arg);
+  float left_val = left->eval(arg);
+
+  return left_val / right_val;
+}
+
 // Multiplication.
 MultiplicationExpression::MultiplicationExpression(Expression *left,
                                                    Expression *right)
@@ -123,6 +181,13 @@ MultiplicationExpression::~MultiplicationExpression() {
   delTree();
 }
 
+float MultiplicationExpression::eval(int arg) {
+  float right_val = right->eval(arg);
+  float left_val = left->eval(arg);
+
+  return left_val * right_val;
+}
+
 // Power.
 PowerExpression::PowerExpression(Expression *left, Expression *right)
   : Expression(left, right, power) {}
@@ -130,3 +195,10 @@ PowerExpression::PowerExpression(Expression *left, Expression *right)
 PowerExpression::~PowerExpression() {
   delTree();
 }
+
+float PowerExpression::eval(int arg) {
+  float right_val = right->eval(arg);
+  float left_val = left->eval(arg);
+
+  return std::pow(left_val, right_val);
+}