Implemented the Multi-directional Broadcasting for SOFIE

Author: Neel-Shah-29

tmva/sofie/inc/TMVA/SOFIE_common.hxx

@@ -105,6 +105,8 @@ ETensorType GetTemplatedType(T /*obj*/ ){
 namespace UTILITY{
 template<typename T>
 T* Unidirectional_broadcast(const T* original_data, const std::vector<size_t> original_shape, const std::vector<size_t> target_shape);
+template <typename T>
+std::vector<size_t> Multidirectional_broadcast(const T* original_data,  std::vector<size_t> input1_shape, std::vector<size_t> input2_shape);
 std::string Clean_name(std::string input_tensor_name);
 
 

tmva/sofie/src/SOFIE_common.cxx

@@ -135,14 +135,65 @@ T* UTILITY::Unidirectional_broadcast(const T* original_data, const std::vector<s
       return new_datavector;
 }
 
+template <typename T>
+std::vector<size_t>  UTILITY::Multidirectional_broadcast(const T* original_data, std::vector<size_t> input1_shape,  std::vector<size_t> input2_shape)
+{
+   std::vector<size_t> input_shape = (input1_shape > input2_shape)?input1_shape:input2_shape;
+   std::vector<size_t> output_shape(input_shape);
+   
+   //check if both the input have same shape, nothing to do directly return the output_shape as the same shape.
+   if(input1_shape.size() == input2_shape.size()){
+      if(input1_shape == input2_shape){
+         return output_shape;
+      }
+      else{
+   //Check the shape values, if input1[i] not equal to input2[i] we have the result shape equal to input1[i] if input2[i] = 1 or viceversa
+         for(size_t j = 0; j < input1_shape.size() ; j++){
+            if(input1_shape[j] == input2_shape[j]){
+               output_shape[j] = input1_shape[j];
+            }
+            else if(input1_shape[j] > input2_shape[j] && input2_shape[j] == 1){
+               output_shape[j] = input1_shape[j];
+            }
+            else if(input2_shape[j] > input1_shape[j] && input1_shape[j] == 1){
+               output_shape[j] = input2_shape[j];
+            }
+         }
+         return output_shape;
+      }
+   }
+   else if(input1_shape.size() < input2_shape.size()){
+   // Check if input1_shape.size() < input2_shape.size() we insert in the shape vector values of 1 at the beginning of the tensor until input1_shape.size() == input2_shape.size()
+      auto it = input1_shape.begin();
+      while (input1_shape.size() < input2_shape.size()) {
+         it = input1_shape.insert(it, 1);
+      }
+      if(input1_shape.size()==input1_shape.size()){
+         UTILITY::Multidirectional_broadcast(original_data,input1_shape,input2_shape);
+      }
+   }
+   else if(input2_shape.size() < input1_shape.size()){
+   // Check if input2_shape.size() < input1_shape.size() we insert in the shape vector values of 1 at the beginning of the tensor until input1_shape.size() == input2_shape.size()
+      auto it = input2_shape.begin();
+      while (input2_shape.size() < input1_shape.size()) {
+         it = input2_shape.insert(it, 1);
+      }
+      if(input1_shape.size()==input1_shape.size()){
+         UTILITY::Multidirectional_broadcast(original_data,input1_shape,input2_shape);
+      }
+   }
+
+}
+
 std::string UTILITY::Clean_name(std::string input_tensor_name){
    std::string s (input_tensor_name);
    s.erase(std::remove_if(s.begin(), s.end(), []( char const& c ) -> bool { return !std::isalnum(c); } ), s.end());
    return s;
 }
 
 template float* UTILITY::Unidirectional_broadcast(const float* original_data, const std::vector<size_t> original_shape, const std::vector<size_t> target_shape);
+template std::vector<size_t>  UTILITY::Multidirectional_broadcast(const float* original_data, std::vector<size_t> input1_shape, std::vector<size_t> input2_shape);
 
 }//SOFIE
 }//Experimental
-}//TMVA
+}//TMVA