[tmva][sofie] Fix binary operators for dynamic tensors

After optmizing the binary operators to void broadcasting, the fix needed to be done also for the case of dynamic tensors

Fix also an issue in semplifying the resulting output shape of Reshape when having dynamic tensor shapes

Author: lmoneta

tmva/sofie/inc/TMVA/ROperator_BasicBinary.hxx

@@ -309,55 +309,73 @@ public:
                // we allocate here output vector
                out << SP << SP << "if (" << fDimShapeA[i] << " != " << fDimShapeB[i] << " && (" << fDimShapeA[i]
                    << " != 1 || " << fDimShapeB[i] << " != 1))\n";
-               out << SP << SP << "throw std::runtime_error(\"SOFIE - Cannot broadcast shapes in operator " << opName
+               out << SP << SP << SP << "throw std::runtime_error(\"SOFIE - Cannot broadcast shapes in operator " << opName
                    << "\");\n";
             }
          }
+         out << SP << "}\n";
       }
 
-      auto stridesA = UTILITY::ComputeStrideFromShape(fShapeA);
-      auto stridesB = UTILITY::ComputeStrideFromShape(fShapeB);
-      auto stridesY = UTILITY::ComputeStrideFromShape(fShapeY);
+      auto stridesA = UTILITY::ComputeStrideFromShape(fDimShapeA);
+      auto stridesB = UTILITY::ComputeStrideFromShape(fDimShapeB);
+      auto stridesY = UTILITY::ComputeStrideFromShape(fDimShapeY);
 
       std::string compute_idx_A, compute_idx_B, compute_idx_Y;
-      if (std::all_of(fShapeA.begin(), fShapeA.end(), [](size_t x) { return x == 1; })) {
+      if (std::all_of(fDimShapeA.begin(), fDimShapeA.end(), [](Dim d) { return d.dim == 1 || d.GetVal() == "1"; })) {
          compute_idx_A = "0";
       } else {
-         for (size_t i = 0; i < fShapeA.size(); ++i) {
-            if (fShapeA[i] == 1)
+         for (size_t i = 0; i < fDimShapeA.size(); ++i) {
+            if (fDimShapeA[i].dim == 1 || fDimShapeA[i].GetVal() == "1")
                continue;
-            compute_idx_A +=
-               " idx_" + std::to_string(i + (fShapeY.size() - fShapeA.size())) + " * " + stridesA[i] + " +";
+            compute_idx_A += "idx_" + std::to_string(i + (fDimShapeY.size() - fDimShapeA.size()));
+            if (stridesA[i].GetVal() != "1")
+               compute_idx_A += " * " + stridesA[i].GetVal();
+            compute_idx_A += " + ";
          }
-         compute_idx_A.pop_back();
+         // remove last 3 character " + "
+         for (int j = 0; j < 3; j++)
+            compute_idx_A.pop_back();
       }
-      if (std::all_of(fShapeB.begin(), fShapeB.end(), [](size_t x) { return x == 1; })) {
+      if (std::all_of(fDimShapeB.begin(), fDimShapeB.end(), [](Dim d) { return d.dim == 1 || d.GetVal() == "1"; })) {
          compute_idx_B = "0";
       } else {
-         for (size_t i = 0; i < fShapeB.size(); ++i) {
-            if (fShapeB[i] == 1)
+         for (size_t i = 0; i < fDimShapeB.size(); ++i) {
+            if (fDimShapeB[i].dim == 1 || fDimShapeB[i].GetVal() == "1")
                continue;
-            compute_idx_B +=
-               " idx_" + std::to_string(i + (fShapeY.size() - fShapeB.size())) + " * " + stridesB[i] + " +";
+            compute_idx_B += "idx_" + std::to_string(i + (fDimShapeY.size() - fDimShapeB.size()));
+            if (stridesB[i].GetVal() != "1")
+               compute_idx_B += " * " + stridesB[i].GetVal();
+            compute_idx_B += " + ";
          }
-         compute_idx_B.pop_back();
+          // remove last 3 character " + "
+         for (int j = 0; j < 3; j++)
+            compute_idx_B.pop_back();
       }
-      for (size_t i = 0; i < fShapeY.size(); ++i) {
-         if (fShapeY[i] != 1) {
-            out << std::string(i + 1, ' ') << "for(size_t idx_" << i << "=0; idx_" << i << "<" << fShapeY[i]
+      int nloop = 0;
+      for (size_t i = 0; i < fDimShapeY.size(); ++i) {
+         if (fDimShapeY[i].dim != 1 && fDimShapeY[i].GetVal() != "1") {
+            nloop++;
+            for (int j = 0; j < nloop; j++) out << SP;
+            out << "for (size_t idx_" << i << " = 0; idx_" << i << " < " << fDimShapeY[i]
                 << "; ++idx_" << i << "){\n";
-            compute_idx_Y += "idx_" + std::to_string(i) + "*" + stridesY[i] + "+";
+            compute_idx_Y += "idx_" + std::to_string(i);
+            if (stridesY[i].GetVal() != "1")
+               compute_idx_Y += " * " + stridesY[i].GetVal();
+            compute_idx_Y += " + ";
          }
       }
-      compute_idx_Y.pop_back();
-      out << SP << SP << "tensor_" << fNY << "[" << compute_idx_Y << "] = "
+      // remove last 3 characters " + "
+      for (int j = 0; j < 3; j++)
+         compute_idx_Y.pop_back();
+      for (int j = 0; j < nloop+1; j++) out << SP;
+      out << "tensor_" << fNY << "[" << compute_idx_Y << "] = "
           << BinaryOperatorTrait<T, Op>::Op("tensor_" + fNA + "[" + compute_idx_A + "]",
                                             "tensor_" + fNB + "[" + compute_idx_B + "]")
           << " ;\n";
-      for (size_t i = 0; i < fShapeY.size(); ++i) {
-         if (fShapeY[i] != 1) {
-            out << std::string(fShapeY.size() - i + 1, ' ') << "}\n";
-         }
+
+      for (int i = nloop; i > 0; i--) {
+         for (int j = 0; j < i; j++) out << SP;
+         out << "}\n";
       }
       return out.str();
    }

tmva/sofie/inc/TMVA/ROperator_Reshape.hxx

@@ -6,7 +6,9 @@
 #include "TMVA/RModel.hxx"
 
 #include <cassert>
+#include <cctype>
 #include <sstream>
+#include <algorithm>
 
 namespace TMVA{
 namespace Experimental{
@@ -100,25 +102,55 @@ public:
                tmp.erase(tmp.begin() + i);
                auto tmp_length = ConvertDimShapeToLength(tmp);
                auto input_length = ConvertDimShapeToLength(input_shape);
+               if (fVerbose)
+                  std::cout << "reshape- try simplifying " << ConvertDimShapeToString(input_shape) << " with length "
+                            << input_length << " to " << tmp_length << std::endl;
+
                if (IsInteger(tmp_length) && IsInteger(input_length))
                   output_shape[i] = Dim{static_cast<size_t>(std::stoi(input_length) / std::stoi(tmp_length))};
                else {
                   //we can try simplifying expression if tmp_length is integer and part of input_length
                   // contains tmp_length
                   bool canSimplify = false;
+                  std::vector <Dim> reduced_input;
                   if (IsInteger(tmp_length)) {
-                     std::vector<Dim> reduced_input = input_shape;
-                     for (auto & s : input_shape) {
-                        if (s.GetVal() == tmp_length) {
-                           //erase value in the reduced_input vector
-                           auto itr = std::find(reduced_input.begin(), reduced_input.end(), s);
-                           reduced_input.erase(itr);
+
+                     // try to tokenize with * the input length
+
+                     std::stringstream ss(input_length);
+
+                     std::string token;
+
+                     // Tokenizing w.r.t. space '*'
+                     while(getline(ss, token, '*'))
+                     {
+                        // remove any whitespace
+                        token.erase(std::remove_if(token.begin(), token.end(),
+                                                   [](unsigned char x) { return std::isspace(x); }), token.end());
+                        if (token != tmp_length) {
+                           if (IsInteger(token)) {
+                                 size_t il = static_cast<size_t>(std::stoi(input_length));
+                                 size_t tl = static_cast<size_t>(std::stoi(tmp_length));
+                                 if ((il % tl) == 0) {
+                                 canSimplify = true;
+                                 reduced_input.push_back(Dim{il / tl});
+                                 }
+                           } else {
+                              reduced_input.push_back(Dim{token});
+                           }
+                        } else {
+                           // token is equal to tmp_length, can be not considered and is simplified
                            canSimplify = true;
-                           break;
                         }
                      }
-                     if (canSimplify)
-                        output_shape[i] = Dim{std::string("(") + ConvertDimShapeToLength(reduced_input) + ")", static_cast<size_t>(-1)};
+                  }
+                  if (canSimplify) {
+                     // if length contains * we need to add some brackets
+                     std::string res_shape = ConvertDimShapeToLength(reduced_input);
+                     if (res_shape.find('*') != std::string::npos)
+                        output_shape[i] = Dim{std::string("(") + res_shape + ")", static_cast<size_t>(-1)};
+                     else
+                        output_shape[i] = Dim{res_shape};
                   }
                   if (!canSimplify)
                      output_shape[i] = Dim{std::string("(") + input_length + " / (" + tmp_length + "))", static_cast<size_t>(-1)};