Renaming

fintarin · Apr 4, 2024 · 517ed38 · 517ed38
1 parent 64dc952
commit 517ed38
Show file tree

Hide file tree

Showing 6 changed files with 19 additions and 19 deletions.
diff --git a/include/fintamath/expressions/ExpressionComparator.hpp b/include/fintamath/expressions/ExpressionComparator.hpp
@@ -7,7 +7,7 @@
 namespace fintamath::detail {
 
 struct ComparatorOptions final {
-  bool constantGreaterThanVariable = false;
+  bool termOrderInversed = false;
   bool comparableOrderInversed = false;
 };
 

diff --git a/include/fintamath/expressions/interfaces/IPolynomExpression.hpp b/include/fintamath/expressions/interfaces/IPolynomExpression.hpp
@@ -47,7 +47,7 @@ class IPolynomExpression : public IExpression {
 
   ArgumentPtr postSimplify() const override;
 
-  virtual bool isConstantGreaterThanVariable() const;
+  virtual bool isTermOrderInversed() const;
 
   virtual bool isComparableOrderInversed() const;
 

diff --git a/src/fintamath/expressions/ExpressionComparator.cpp b/src/fintamath/expressions/ExpressionComparator.cpp
@@ -141,11 +141,11 @@ Ordering compareTerms(const ArgumentPtr &lhs,
   }
 
   if (lhsTerm && !rhsTerm) {
-    return !options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return !options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
 
   if (!lhsTerm && rhsTerm) {
-    return options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
 
   while (lhsTerm && rhsTerm) {
@@ -205,17 +205,17 @@ Ordering compareNonExpressions(const ArgumentPtr &lhs,
                                const ComparatorOptions &options) {
 
   if (is<ILiteral>(lhs) && !is<ILiteral>(rhs)) {
-    return !options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return !options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
   if (!is<ILiteral>(lhs) && is<ILiteral>(rhs)) {
-    return options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
 
   if (is<Variable>(lhs) && !is<Variable>(rhs)) {
-    return !options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return !options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
   if (!is<Variable>(lhs) && is<Variable>(rhs)) {
-    return options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
 
   if (*lhs == *rhs) {
@@ -269,7 +269,7 @@ Ordering compareExpressions(const std::shared_ptr<const IExpression> &lhs,
   }
 
   ComparatorOptions childCompOptions = options;
-  childCompOptions.constantGreaterThanVariable = false;
+  childCompOptions.termOrderInversed = false;
   const ChildrenComparatorResult childrenComp = compareChildren(lhs->getChildren(), rhs->getChildren(), childCompOptions);
 
   if (childrenComp.prefixVariables != Ordering::equal) {
@@ -317,15 +317,15 @@ Ordering compareExpressionAndNonExpression(const std::shared_ptr<const IExpressi
                                            const ComparatorOptions &options) {
 
   if (!is<ILiteral>(rhs)) {
-    return !options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return !options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
 
   if (const auto res = compareTerms<Variable>(lhs, rhs, options); res != Ordering::equal) {
     return res;
   }
 
   if (!is<IOperator>(lhs->getFunction())) {
-    return !options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return !options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
 
   if (const auto res = compareTerms<ILiteral>(lhs, rhs, options); res != Ordering::equal) {
@@ -346,26 +346,26 @@ Ordering compareExpressionAndNonExpression(const std::shared_ptr<const IExpressi
       case IOperator::Priority::Multiplication: {
         const ArgumentPtr rhsExpr = makeExpr(*lhsOper, rhs, Integer(1).clone());
         const Ordering res = compare(lhs, rhsExpr);
-        return options.constantGreaterThanVariable ? reverse(res) : res;
+        return options.termOrderInversed ? reverse(res) : res;
       }
       default: {
         break;
       }
     }
   }
 
-  return !options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+  return !options.termOrderInversed ? Ordering::greater : Ordering::less;
 }
 
 Ordering compareFunctions(const std::shared_ptr<const IFunction> &lhs,
                           const std::shared_ptr<const IFunction> &rhs,
                           const ComparatorOptions &options) {
 
   if (is<IOperator>(lhs) && !is<IOperator>(rhs)) {
-    return options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
   if (!is<IOperator>(lhs) && is<IOperator>(rhs)) {
-    return !options.constantGreaterThanVariable ? Ordering::greater : Ordering::less;
+    return !options.termOrderInversed ? Ordering::greater : Ordering::less;
   }
 
   if (*lhs == *rhs) {

diff --git a/src/fintamath/expressions/interfaces/IPolynomExpression.cpp b/src/fintamath/expressions/interfaces/IPolynomExpression.cpp
@@ -202,13 +202,13 @@ std::string IPolynomExpression::childToString(const IOperator &oper, const Argum
 
 std::strong_ordering IPolynomExpression::compare(const ArgumentPtr &lhs, const ArgumentPtr &rhs) const {
   const ComparatorOptions options = {
-      .constantGreaterThanVariable = isConstantGreaterThanVariable(),
+      .termOrderInversed = isTermOrderInversed(),
       .comparableOrderInversed = isComparableOrderInversed(),
   };
   return fintamath::compare(lhs, rhs, options);
 }
 
-bool IPolynomExpression::isConstantGreaterThanVariable() const {
+bool IPolynomExpression::isTermOrderInversed() const {
   return false;
 }
 

diff --git a/src/fintamath/expressions/polynomial/MulExpr.cpp b/src/fintamath/expressions/polynomial/MulExpr.cpp
@@ -105,7 +105,7 @@ MulExpr::SimplifyFunctionVector MulExpr::getFunctionsForPostSimplify() const {
   return simplifyFunctions;
 }
 
-bool MulExpr::isConstantGreaterThanVariable() const {
+bool MulExpr::isTermOrderInversed() const {
   return true;
 }
 

diff --git a/src/fintamath/expressions/polynomial/MulExpr.hpp b/src/fintamath/expressions/polynomial/MulExpr.hpp
@@ -23,7 +23,7 @@ class MulExpr final : public IPolynomExpressionCRTP<MulExpr> {
 
   SimplifyFunctionVector getFunctionsForPostSimplify() const override;
 
-  bool isConstantGreaterThanVariable() const override;
+  bool isTermOrderInversed() const override;
 
 private:
   static ArgumentPtr constSimplify(const IFunction &func, const ArgumentPtr &lhs, const ArgumentPtr &rhs);