Añadida implementación dle diferenciados.

1 files changed, 38 insertions, 2 deletions

diff --git a/expressions.cpp b/expressions.cpp
index 08520f7..c7d80e3 100644
--- a/expressions.cpp
+++ b/expressions.cpp
@@ -25,6 +25,10 @@ float Literal::eval(int arg) {
   return getValue();
 }
 
+Expression *Literal::copy() {
+  return new Literal(value);
+}
+
 // Función.
 Function::Function(Expression *arg, trig_functions name) : Expression(NULL, NULL, function) {
   this->arg = arg;
@@ -35,11 +39,11 @@ Function::~Function() {
   delTree();
 }
 
-const Expression *Function::getArg() {
+const Expression *Function::getArg() const {
   return arg;
 }
 
-trig_functions Function::getFunctionName() {
+trig_functions Function::getFunctionName() const {
   return function_name;
 }
 
@@ -99,6 +103,10 @@ void Function::setRepr() {
   repr += ')';
 }
 
+Expression *Function::copy() {
+  return new Function(arg->copy(), function_name);
+}
+
 // Variable.
 Variable::Variable(char name) : Expression(NULL, NULL, variable) {
   this->name = name;
@@ -115,6 +123,10 @@ float Variable::eval(int arg) {
   return arg;
 }
 
+Expression *Variable::copy() {
+  return new Variable(name);
+}
+
 // Suma.
 AddExpression::AddExpression(Expression *left, Expression *right)
   : Expression(left, right, sum) {}
@@ -130,6 +142,10 @@ float AddExpression::eval(int arg) {
   return right_val + left_val;
 }
 
+Expression *AddExpression::copy() {
+  return new AddExpression(left->copy(), right->copy());
+}
+
 // Substracción.
 SubExpression::SubExpression(Expression *left, Expression *right)
   : Expression(left, right, substraction) {}
@@ -145,6 +161,10 @@ float SubExpression::eval(int arg) {
   return right_val - left_val;
 }
 
+Expression *SubExpression::copy() {
+  return new SubExpression(left->copy(), right->copy());
+}
+
 // Negación.
 NegationExpression::NegationExpression(Expression *right)
   : Expression(NULL, right, substraction) {}
@@ -164,6 +184,10 @@ float NegationExpression::eval(int arg) {
   return -1 * expr_value;
 }
 
+Expression *NegationExpression::copy() {
+  return new NegationExpression(right->copy());
+}
+
 // División.
 DivisionExpression::DivisionExpression(Expression *left, Expression *right)
   : Expression(left, right, division) {}
@@ -179,6 +203,10 @@ float DivisionExpression::eval(int arg) {
   return left_val / right_val;
 }
 
+Expression *DivisionExpression::copy() {
+  return new DivisionExpression(left->copy(), right->copy());
+}
+
 // Multiplicación.
 MultiplicationExpression::MultiplicationExpression(Expression *left,
                                                    Expression *right)
@@ -195,6 +223,10 @@ float MultiplicationExpression::eval(int arg) {
   return left_val * right_val;
 }
 
+Expression *MultiplicationExpression::copy() {
+  return new MultiplicationExpression(left->copy(), right->copy());
+}
+
 // Potencia.
 PowerExpression::PowerExpression(Expression *left, Expression *right)
   : Expression(left, right, power) {}
@@ -209,3 +241,7 @@ float PowerExpression::eval(int arg) {
 
   return std::pow(left_val, right_val);
 }
+
+Expression *PowerExpression::copy() {
+  return new PowerExpression(left->copy(), right->copy());
+}