std::views, projections

include/fintamath/core/MathObjectTypes.hpp

@@ -188,22 +188,10 @@ struct hash<fintamath::MathObjectType> {
 namespace fintamath {
 
 class MathObjectBoundTypes {
-  static constexpr auto getTypeHash = [](const MathObjectType &type) { return size_t(type); };
-
-  using TypeMap = std::unordered_map<MathObjectType, MathObjectType>;
-
   using enum MathObjectType::Id;
 
-public:
-  static const TypeMap &get() {
-    return getMutable();
-  }
-
-  static void reg(const MathObjectType &type, const MathObjectType &boundType) {
-    getMutable().emplace(type, boundType);
-  }
+  using TypeMap = std::unordered_map<MathObjectType, MathObjectType>;
 
-private:
   static TypeMap &getMutable() {
     static TypeMap ids{
         {IMathObject, None},
@@ -223,6 +211,15 @@ class MathObjectBoundTypes {
 
     return ids;
   }
+
+public:
+  static const TypeMap &get() {
+    return getMutable();
+  }
+
+  static void reg(const MathObjectType &type, const MathObjectType &boundType) {
+    getMutable().emplace(type, boundType);
+  }
 };
 
 inline bool isBaseOf(const MathObjectType &toType, const MathObjectType &fromType) {

include/fintamath/expressions/IExpressionCRTP.hpp

@@ -24,7 +24,7 @@ class IExpressionCRTP_ : public IExpressionBaseCRTP<Derived, isMultiFunction> {
       return false;
     }
 
-    for (size_t i = 0; i < lhsChildren.size(); i++) {
+    for (auto i : std::views::iota(0U, lhsChildren.size())) {
       if (lhsChildren[i] != rhsChildren[i] && *lhsChildren[i] != *rhsChildren[i]) {
         return false;
       }

include/fintamath/functions/IFunctionCRTP.hpp

@@ -116,7 +116,7 @@ class IFunctionCRTP_ : public IFunction {
   void throwInvalidInputFunctionException(const ArgumentRefVector &argsVect) const {
     std::vector<std::string> argNamesVect(argsVect.size());
 
-    for (size_t i = 0; i < argNamesVect.size(); i++) {
+    for (auto i : std::views::iota(0U, argNamesVect.size())) {
       argNamesVect[i] = argsVect[i].get().toString();
     }
 

include/fintamath/parser/Parser.hpp

@@ -3,6 +3,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <ranges>
 #include <string>
 #include <vector>
 
@@ -71,7 +72,7 @@ class Parser {
 
     const auto &valuePairs = parserMap.equal_range(parsedStr);
 
-    for (auto pair = valuePairs.first; pair != valuePairs.second; pair++) {
+    for (auto pair : std::views::iota(valuePairs.first, valuePairs.second)) {
       if (Return value = pair->second(args...)) {
         return value;
       }
@@ -88,7 +89,7 @@ class Parser {
 
     const auto &valuePairs = parserMap.equal_range(parsedStr);
 
-    for (auto pair = valuePairs.first; pair != valuePairs.second; pair++) {
+    for (auto pair : std::views::iota(valuePairs.first, valuePairs.second)) {
       if (Return value = pair->second(move(args)...)) {
         return value;
       }
@@ -105,7 +106,7 @@ class Parser {
 
     const auto &valuePairs = parserMap.equal_range(parsedStr);
 
-    for (auto pair = valuePairs.first; pair != valuePairs.second; pair++) {
+    for (auto pair : std::views::iota(valuePairs.first, valuePairs.second)) {
       if (Return value = pair->second(args...); value && comp(value)) {
         return value;
       }
@@ -123,7 +124,7 @@ class Parser {
 
     const auto &valuePairs = parserMap.equal_range(parsedStr);
 
-    for (auto pair = valuePairs.first; pair != valuePairs.second; pair++) {
+    for (auto pair : std::views::iota(valuePairs.first, valuePairs.second)) {
       if (Return value = pair->second(move(args)...); value && comp(value)) {
         return value;
       }

src/fintamath/expressions/Expression.cpp

@@ -281,7 +281,7 @@ TermVector Expression::tokensToTerms(const TokenVector &tokens) {
 
   TermVector terms(tokens.size());
 
-  for (size_t i = 0; i < tokens.size(); i++) {
+  for (auto i : std::views::iota(0U, terms.size())) {
     if (auto term = Parser::parse(getTermMakers(), (tokens[i]))) {
       terms[i] = std::move(term);
     }
@@ -334,7 +334,7 @@ void Expression::fixOperatorTypes(TermVector &terms) {
     return;
   }
 
-  for (size_t i = 1; i < terms.size() - 1; i++) {
+  for (auto i : std::views::iota(1U, terms.size() - 1)) {
     const auto &term = terms[i];
     const auto &termPrev = terms[i - 1];
 
@@ -347,7 +347,8 @@ void Expression::fixOperatorTypes(TermVector &terms) {
     }
   }
 
-  for (size_t i = terms.size() - 2; i > 1; i--) {
+  // TODO: use reverse(iota(1, terms.size() - 1)) when it is work
+  for (size_t i = terms.size() - 2; i > 0; i--) {
     const auto &term = terms[i];
     const auto &termNext = terms[i + 1];
 
@@ -406,7 +407,7 @@ bool Expression::skipBrackets(const TermVector &terms, size_t &openBracketIndex)
 
   int64_t brackets = 0;
 
-  for (size_t i = openBracketIndex; i < terms.size(); i++) {
+  for (auto i : std::views::iota(openBracketIndex, terms.size())) {
     const auto &term = terms[i];
 
     if (term->name == "(") {
@@ -479,8 +480,8 @@ void Expression::validateChild(const ArgumentPtr &inChild) {
     validateFunctionArgs(func, children);
   }
   else {
-    for (size_t i = 0; i + 1 < children.size(); i++) {
-      for (size_t j = i + 1; j < children.size(); j++) {
+    for (auto i : std::views::iota(0U, children.size() - 1)) {
+      for (auto j : std::views::iota(i + 1, children.size())) {
         validateFunctionArgs(func, {children[i], children[j]});
       }
     }
@@ -502,7 +503,7 @@ void Expression::validateFunctionArgs(const std::shared_ptr<IFunction> &func, co
     childrenTypes = ArgumentTypeVector(args.size(), childrenTypes.front());
   }
 
-  for (size_t i = 0; i < args.size(); i++) {
+  for (auto i : std::views::iota(0U, args.size())) {
     const ArgumentPtr &arg = args[i];
     const MathObjectType Type = childrenTypes[i];
 

src/fintamath/expressions/ExpressionUtils.cpp

@@ -233,7 +233,7 @@ bool isNegated(const ArgumentPtr &arg) {
 std::vector<std::string> argumentVectorToStringVector(const ArgumentPtrVector &args) {
   std::vector<std::string> argStrings(args.size());
 
-  for (size_t i = 0; i < argStrings.size(); i++) {
+  for (auto i : std::views::iota(0U, argStrings.size())) {
     argStrings[i] = args[i].get()->toString();
   }
 

src/fintamath/expressions/IExpression.cpp

@@ -25,9 +25,7 @@ std::vector<Variable> IExpression::getVariables() const {
     }
   }
 
-  std::ranges::sort(vars, [](const Variable &lhs, const Variable &rhs) {
-    return lhs.toString() < rhs.toString();
-  });
+  std::ranges::sort(vars, std::less(), &Variable::toString);
   auto unique = std::ranges::unique(vars);
   vars.erase(unique.begin(), unique.end());
 

src/fintamath/expressions/binary/DivExpression.cpp

@@ -160,16 +160,20 @@ ArgumentPtr DivExpression::mulSimplify(const IFunction &func, const ArgumentPtr
   size_t lhsChildrenSizeInitial = lhsChildren.size();
   size_t rhsChildrenSizeInitial = rhsChildren.size();
 
-  for (auto &lhsChild : lhsChildren) {
-    for (size_t j = 0; j < rhsChildren.size(); j++) {
-      ArgumentPtr res = constSimplify(func, lhsChild, rhsChildren[j]);
+  // TODO: use more efficient algorithm
+  for (auto i : std::views::iota(0U, lhsChildren.size())) {
+    auto &lhsChild = lhsChildren[i];
+
+    for (auto j : std::views::iota(0U, rhsChildren.size())) {
+      const auto &rhsChild = rhsChildren[j];
+      ArgumentPtr res = constSimplify(func, lhsChild, rhsChild);
 
       if (!res) {
-        res = callFunction(Div(), {lhsChild, rhsChildren[j]});
+        res = callFunction(Div(), {lhsChild, rhsChild});
       }
 
       if (!res) {
-        res = powSimplify(lhsChild, rhsChildren[j]);
+        res = powSimplify(lhsChild, rhsChild);
       }
 
       if (res && !is<Rational>(res)) {
@@ -360,7 +364,7 @@ std::pair<ArgumentPtr, ArgumentPtr> DivExpression::mulSumSimplify(const Argument
 
   ArgumentPtrVector multiplicator;
 
-  for (size_t i = 1; i < rhsChildren.size(); i++) {
+  for (auto i : std::views::iota(1U, rhsChildren.size())) {
     multiplicator.emplace_back(mulExpr(rhsChildren[i], result));
   }
 

src/fintamath/expressions/binary/PowExpression.cpp

@@ -98,8 +98,9 @@ PowExpression::SimplifyFunctionVector PowExpression::getFunctionsForPostSimplify
 Integer PowExpression::generateFirstNum(const Integer &countOfOne) {
   Integer n = 0;
 
-  for (int i = 0; i < countOfOne; i++) {
-    n = n << 1 | 1;
+  for ([[maybe_unused]] auto _ : std::views::iota(0U, countOfOne)) {
+    n <<= 1;
+    n |= 1;
   }
 
   return n;
@@ -147,20 +148,21 @@ ArgumentPtr PowExpression::sumPolynomSimplify(const ArgumentPtr &expr, const Int
     return {};
   }
 
-  ArgumentPtrVector newPolynom;
-  Integer variableCount = int64_t(polynom.size());
-
+  size_t variableCount = polynom.size();
   Integer bitNumber = generateFirstNum(powValue);
+  Integer combins = combinations(powValue + variableCount - 1, powValue);
+
+  ArgumentPtrVector newPolynom;
 
-  for (int i = 0; i < combinations(powValue + variableCount - 1, powValue); i++) {
-    std::vector<Integer> vectOfPows = getPartition(bitNumber, variableCount);
+  for ([[maybe_unused]] auto _ : std::views::iota(0U, combins)) {
+    std::vector<Integer> vectOfPows = getPartition(bitNumber, Integer(variableCount));
     bitNumber = generateNextNumber(bitNumber);
 
     ArgumentPtrVector mulExprPolynom;
     mulExprPolynom.emplace_back(multinomialCoefficient(powValue, vectOfPows).clone());
 
-    for (size_t j = 0; j < size_t(variableCount); j++) {
-      ArgumentPtr powExprChild = powExpr(polynom[j], vectOfPows[j].clone());
+    for (auto i : std::views::iota(0U, variableCount)) {
+      ArgumentPtr powExprChild = powExpr(polynom[i], vectOfPows[i].clone());
       mulExprPolynom.emplace_back(powExprChild);
     }
 

src/fintamath/expressions/functions/ExpressionFunctionSolve.cpp

@@ -163,8 +163,8 @@ ArgumentPtrVector getVariableIntPowerRates(const ArgumentPtr &elem, const Variab
     std::shared_ptr<const INumber> power = getElementPower(polynomChild, var);
 
     if (auto intPow = cast<Integer>(power)) {
-      if (int64_t(powerRates.size()) < *intPow + 1) {
-        while (int64_t(powerRates.size()) != *intPow + 1) {
+      if (powerRates.size() < *intPow + 1) {
+        while (powerRates.size() != *intPow + 1) {
           powerRates.emplace_back(Integer(0).clone());
         }
       }

src/fintamath/expressions/interfaces/IPolynomExpression.cpp

@@ -30,7 +30,7 @@ std::string IPolynomExpression::toString() const {
 
   result += childToString(*oper, children.front(), {});
 
-  for (size_t i = 1; i < children.size(); i++) {
+  for (auto i : std::views::iota(1U, children.size())) {
     const std::string childStr = childToString(*oper, children[i], children[i - 1]);
 
     if (childStr.length() > 2 && childStr[0] == ' ' && std::isdigit(childStr[1]) && std::isdigit(result.back())) {
@@ -91,6 +91,7 @@ void IPolynomExpression::simplifyRec(bool isPostSimplify) {
 
   bool isSimplified = true;
 
+  // TODO: refactor this loop
   for (size_t i = 1; i < children.size(); i++) {
     const ArgumentPtr &lhs = children[i - 1];
     const ArgumentPtr &rhs = children[i];
@@ -447,7 +448,9 @@ IPolynomExpression::comparatorChildren(const ArgumentPtrVector &lhsChildren,
     result.postfixUnary = 0;
   }
 
-  for (size_t i = 0; i < std::min(std::max(lhsStart, rhsStart), std::min(lhsChildren.size(), rhsChildren.size())); i++) {
+  for (auto end = std::min(std::max(lhsStart, rhsStart), std::min(lhsChildren.size(), rhsChildren.size()));
+       auto i : std::views::iota(0U, end)) {
+
     int childrenComp = comparator(lhsChildren[i], rhsChildren[i]);
 
     if (childrenComp != 0) {
@@ -538,6 +541,7 @@ std::shared_ptr<const Variable> IPolynomExpression::getNextVariable(ExpressionTr
   while (!stack.empty()) {
     ArgumentPtrVector children = stack.top().first->getChildren();
 
+    // TODO: looks weird
     size_t &exprIndex = stack.top().second;
     exprIndex++;
 
@@ -566,11 +570,12 @@ std::shared_ptr<const Variable> IPolynomExpression::getNextVariable(ExpressionTr
 }
 
 size_t IPolynomExpression::getPositionOfFirstChildWithVariable(const ArgumentPtrVector &children) {
-  for (size_t i = 0; i < children.size(); i++) {
+  for (auto i : std::views::iota(0U, children.size())) {
     auto lhsChildExpr = cast<IExpression>(children[i]);
 
     if (is<Variable>(children[i]) ||
         (lhsChildExpr && hasVariable(lhsChildExpr))) {
+
       return i;
     }
   }

src/fintamath/expressions/polynomial/AddExpression.cpp

@@ -265,7 +265,7 @@ ArgumentPtr AddExpression::addRatesToValue(const ArgumentPtrVector &rates, const
 std::vector<size_t> AddExpression::findLogarithms(const ArgumentPtrVector &children) {
   std::vector<size_t> indexes;
 
-  for (size_t i = 0; i < children.size(); i++) {
+  for (auto i : std::views::iota(0U, children.size())) {
     if (const auto childExpr = cast<const IExpression>(children[i]);
         childExpr && is<Log>(childExpr->getFunction())) {
 

src/fintamath/expressions/polynomial/OrExpression.cpp

@@ -34,12 +34,13 @@ ArgumentPtr OrExpression::postSimplify() const {
   auto simplChildren = simpl->children;
   auto simplChildrenSizeInitial = simplChildren.size();
 
+  // TODO: use more efficient algorithm
   for (size_t i = 0; i + 1 < simplChildren.size(); i++) {
     for (size_t j = i + 1; j < simplChildren.size(); j++) {
       if (auto res = absorptionSimplify(simplChildren[i], simplChildren[j])) {
         simplChildren[i] = res;
         simplChildren.erase(simplChildren.begin() + ptrdiff_t(j));
-        break;
+        j--;
       }
     }
   }
@@ -131,7 +132,7 @@ ArgumentPtr OrExpression::andSimplify(const IFunction & /*func*/, const Argument
 
   size_t resolutionIndex = lhsChildren.size();
 
-  for (size_t i = 0; i < lhsChildren.size(); i++) {
+  for (auto i : std::views::iota(0U, lhsChildren.size())) {
     ArgumentPtr lhsSubChild = lhsChildren[i];
     ArgumentPtr rhsSubChild = rhsChildren[i];
 
@@ -213,10 +214,17 @@ ArgumentPtr OrExpression::absorptionSimplify(const ArgumentPtr &lhsChild, const
   ArgumentPtrVector minChildren = lhsChildren.size() < rhsChildren.size() ? lhsChildren : rhsChildren;
   size_t matchCount = 0;
 
-  for (size_t i = 0, j = 0; i < maxChildren.size() && j < minChildren.size(); i++) {
-    if (*maxChildren[i] == *minChildren[j]) {
-      matchCount++;
-      j++;
+  {
+    size_t i = 0;
+    size_t j = 0;
+
+    while (i < maxChildren.size() && j < minChildren.size()) {
+      if (*maxChildren[i] == *minChildren[j]) {
+        matchCount++;
+        j++;
+      }
+
+      i++;
     }
   }
 

src/fintamath/functions/calculus/Max.cpp

@@ -7,7 +7,7 @@ namespace fintamath {
 std::unique_ptr<IMathObject> Max::call(const ArgumentRefVector &argsVect) const {
   std::reference_wrapper<const IComparable> res = cast<IComparable>(argsVect.front().get());
 
-  for (size_t i = 1; i < argsVect.size(); i++) {
+  for (auto i : std::views::iota(1U, argsVect.size())) {
     std::reference_wrapper<const IComparable> arg = cast<IComparable>(argsVect[i].get());
 
     if (is<Complex>(arg)) {

src/fintamath/functions/calculus/Min.cpp

@@ -6,7 +6,7 @@ namespace fintamath {
 std::unique_ptr<IMathObject> Min::call(const ArgumentRefVector &argsVect) const {
   std::reference_wrapper<const IComparable> res = cast<IComparable>(argsVect.front().get());
 
-  for (size_t i = 1; i < argsVect.size(); i++) {
+  for (auto i : std::views::iota(1U, argsVect.size())) {
     std::reference_wrapper<const IComparable> arg = cast<IComparable>(argsVect[i].get());
 
     if (is<Complex>(arg)) {