Made all const references

Author: AzizZayed

cas/include/cas/node/Abs.h

@@ -11,7 +11,7 @@ CAS_NAMESPACE
 
 class Abs : public BracketExpression {
 public:
-    explicit Abs(ExprPtr argument);
+    explicit Abs(const ExprPtr& argument);
 
     Abs() = delete;
 
@@ -25,7 +25,7 @@ class Abs : public BracketExpression {
 
     std::string text() override;
 
-    static ExprPtr from(ExprPtr argument) {
+    static ExprPtr from(const ExprPtr& argument) {
         return std::make_shared<Abs>(argument);
     }
 };

cas/include/cas/node/BracketExpression.h

@@ -15,7 +15,7 @@ class BracketExpression : public UnaryExpression {
 
     ~BracketExpression() override = default;
 
-    bool _equals(ExprPtr other) override;
+    bool _equals(const ExprPtr& other) override;
 
     ExprPtr derivative(char var) override;
 
@@ -28,7 +28,7 @@ class BracketExpression : public UnaryExpression {
     std::string explicitText() override;
 
 protected:
-    explicit BracketExpression(const ExpressionProperties& properties, ExprPtr argument,
+    explicit BracketExpression(const ExpressionProperties& properties, const ExprPtr& argument,
                                const wchar_t* openBracket, const wchar_t* closeBracket,
                                const char* openBracketLatex, const char* closeBracketLatex);
 

cas/include/cas/node/Cbrt.h

@@ -11,7 +11,7 @@ CAS_NAMESPACE
 
 class Cbrt : public Root {
 public:
-    explicit Cbrt(ExprPtr base);
+    explicit Cbrt(const ExprPtr& base);
     Cbrt() = delete;
     ~Cbrt() override = default;
 
@@ -25,7 +25,7 @@ class Cbrt : public Root {
     std::string text() override;
     std::string explicitText() override;
 
-    static CbrtPtr from(ExprPtr base) { return std::make_shared<Cbrt>(base); }
+    static CbrtPtr from(const ExprPtr& base) { return std::make_shared<Cbrt>(base); }
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/Ceil.h

@@ -11,7 +11,7 @@ CAS_NAMESPACE
 
 class Ceil : public BracketExpression {
 public:
-    explicit Ceil(ExprPtr argument);
+    explicit Ceil(const ExprPtr& argument);
 
     Ceil() = delete;
 
@@ -23,7 +23,7 @@ class Ceil : public BracketExpression {
 
     ExprPtr simplified() override;
 
-    static ExprPtr from(ExprPtr argument) {
+    static ExprPtr from(const ExprPtr& argument) {
         return std::make_shared<Ceil>(argument);
     }
 };

cas/include/cas/node/Const.h

@@ -18,7 +18,7 @@ class Const : public Expr {
 
     double evaluate(const VariableMap& variables) override;
 
-    bool _equals(ExprPtr expression) override;
+    bool _equals(const ExprPtr& expression) override;
 
     ExprPtr clone() override;
 

cas/include/cas/node/Divide.h

@@ -13,13 +13,13 @@ CAS_NAMESPACE
 class Divide : public Expr {
 public:
     Divide() = delete;
-    explicit Divide(ExprPtr dividend, ExprPtr divisor);
+    explicit Divide(const ExprPtr& dividend, const ExprPtr& divisor);
 
     ~Divide() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    bool _equals(ExprPtr expression) override;
+    bool _equals(const ExprPtr& expression) override;
 
     ExprPtr clone() override;
 
@@ -35,14 +35,11 @@ class Divide : public Expr {
 
     std::string explicitText() override;
 
-    static DividePtr from(ExprPtr dividend, ExprPtr divisor) { return std::make_shared<Divide>(dividend, divisor); }
+    static DividePtr from(const ExprPtr& dividend, const ExprPtr& divisor) { return std::make_shared<Divide>(dividend, divisor); }
 
     ExprPtr getDividend() const { return dividend; }
     ExprPtr getDivisor() const { return divisor; }
 
-private:
-    void setParents();
-
 private:
     ExprPtr dividend;
     ExprPtr divisor;

cas/include/cas/node/Exp.h

@@ -11,7 +11,7 @@ CAS_NAMESPACE
 
 class Exp : public Power {
 public:
-    explicit Exp(ExprPtr exponent);
+    explicit Exp(const ExprPtr& exponent);
 
     Exp() = delete;
 
@@ -27,7 +27,7 @@ class Exp : public Power {
 
     std::string explicitText() override;
 
-    static ExpPtr from(ExprPtr exponent) { return std::make_shared<Exp>(exponent); }
+    static ExpPtr from(const ExprPtr& exponent) { return std::make_shared<Exp>(exponent); }
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/Expression.h

@@ -100,35 +100,35 @@ class Expr : public IMath<ExprPtr>, public IRepresentableMath, public std::enabl
     double evaluate(const VariableMap& variables) override;
     virtual double evaluate();
 
-    virtual bool equals(ExprPtr expression);
-    virtual bool _equals(ExprPtr expression);
+    virtual bool equals(const ExprPtr& expression);
+    virtual bool _equals(const ExprPtr& expression);
 
     virtual ExprPtr clone();
 
     ExprPtr derivative(char var) override;
     virtual ExprPtr _derivative(char var);
 
     ExprPtr simplified() override;
-    bool isEquivalent(ExprPtr expression) override;
+    bool isEquivalent(const ExprPtr& expression) override;
 
-    ProdPtr multiply(ExprPtr expression);
+    ProdPtr multiply(const ExprPtr& expression);
     ProdPtr multiply(double value);
-    SumPtr add(ExprPtr expression);
-    SumPtr subtract(ExprPtr expression);
+    SumPtr add(const ExprPtr& expression);
+    SumPtr subtract(const ExprPtr& expression);
     SumPtr add(double value);
     SumPtr subtract(double value);
-    DividePtr divide(ExprPtr expression);
+    DividePtr divide(const ExprPtr& expression);
     DividePtr divide(double divisor);
     NegatePtr negate();
 
-    PowerPtr power(ExprPtr expression);
+    PowerPtr power(const ExprPtr& expression);
     PowerPtr power(double exponent);
     ExpPtr exp();
-    LogPtr log(ExprPtr base);
+    LogPtr log(const ExprPtr& base);
     LogPtr log(double base);
     LnPtr ln();
 
-    RootPtr root(ExprPtr root);
+    RootPtr root(const ExprPtr& root);
     RootPtr root(double root);
     SqrtPtr sqrt();
     CbrtPtr cbrt();
@@ -151,15 +151,15 @@ class Expr : public IMath<ExprPtr>, public IRepresentableMath, public std::enabl
     CeilPtr ceil();
     RoundPtr round();
     SignPtr sign();
-    ModPtr mod(ExprPtr expression);
+    ModPtr mod(const ExprPtr& expression);
 
     ExprPtr reciprocal();
 
     bool operator<(const Expr& expression) const;
 
-    bool lessThan(ExprPtr expression) const;
+    bool lessThan(const ExprPtr& expression) const;
 
-    static bool compare(ExprPtr left, ExprPtr right);
+    static bool compare(const ExprPtr& left, const ExprPtr& right);
 
     ExpressionProperties getProperties() const;
 
@@ -171,7 +171,7 @@ class Expr : public IMath<ExprPtr>, public IRepresentableMath, public std::enabl
 
     bool isOfType(ExpressionType type) const;
 
-    bool isOfSameType(ExprPtr expression) const;
+    bool isOfSameType(const ExprPtr& expression) const;
 
     // TODO overload math operators + - * / ^
 

cas/include/cas/node/Floor.h

@@ -11,7 +11,7 @@ CAS_NAMESPACE
 
 class Floor : public BracketExpression {
 public:
-    explicit Floor(ExprPtr argument);
+    explicit Floor(const ExprPtr& argument);
 
     Floor() = delete;
 
@@ -23,7 +23,7 @@ class Floor : public BracketExpression {
 
     ExprPtr simplified() override;
 
-    static FloorPtr from(ExprPtr argument) { return std::make_shared<Floor>(argument); }
+    static FloorPtr from(const ExprPtr& argument) { return std::make_shared<Floor>(argument); }
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/IMath.h

@@ -17,7 +17,7 @@ class IMath {
     virtual double evaluate(const VariableMap& variables) = 0;
     virtual E derivative(char var) = 0;
     virtual E simplified() = 0;
-    virtual bool isEquivalent(E expr) = 0;
+    virtual bool isEquivalent(const E& expr) = 0;
 };
 
 namespace math {