Changeset 25479

Timestamp:

2015-04-09T21:30:17+02:00 (9 years ago)

Author:

rfranke

Message:

implement multiply_array for 1D and 2D arrays

Nothing to be proud of ... but better than a missing matrix multiplication.

Location:

trunk/SimulationRuntime/cpp

Files:

• Core/Math/ArrayOperations.cpp (modified) (2 diffs)
• Include/Core/Math/Array.h (modified) (2 diffs)
• Include/Core/Math/ArrayOperations.h (modified) (1 diff)
• Include/Core/Math/ArraySlice.h (modified) (1 diff)

trunk/SimulationRuntime/cpp/Core/Math/ArrayOperations.cpp

@@ -185 +185 @@
 };
 
+template <typename T>
+void multiply_array(const BaseArray<T> &leftArray, const BaseArray<T> &rightArray, BaseArray<T> &resultArray)
+{
+  size_t leftNumDims = leftArray.getNumDims();
+  size_t rightNumDims = rightArray.getNumDims();
+  size_t matchDim = rightArray.getDim(1);
+  if (leftArray.getDim(leftNumDims) != matchDim)
+    throw ModelicaSimulationError(MODEL_ARRAY_FUNCTION,
+                                  "Wrong sizes in multiply_array");
+  if (matchDim == 0) {
+    fill_array(resultArray, T()); // zero
+  }
+  else if (leftNumDims == 1 && rightNumDims == 2) {
+    size_t rightDim = rightArray.getDim(2);
+    for (size_t j = 1; j <= rightDim; j++) {
+      T val = leftArray(1) * rightArray(1, j);
+      for (size_t k = 2; k <= matchDim; k++)
+        val += leftArray(k) * rightArray(k, j);
+      resultArray(j) = val;
+    }
+  }
+  else if (leftNumDims == 2 && rightNumDims == 1) {
+    size_t leftDim = leftArray.getDim(1);
+    for (size_t i = 1; i <= leftDim; i++) {
+      T val = leftArray(i, 1) * rightArray(1);
+      for (size_t k = 2; k <= matchDim; k++)
+        val += leftArray(i, k) * rightArray(k);
+      resultArray(i) = val;
+    }
+  }
+  else if (leftNumDims == 2 && rightNumDims == 2) {
+    size_t leftDim = leftArray.getDim(1);
+    size_t rightDim = rightArray.getDim(2);
+    for (size_t i = 1; i <= leftDim; i++) {
+      for (size_t j = 1; j <= rightDim; j++) {
+        T val = leftArray(i, 1) * rightArray(1, j);
+        for (size_t k = 2; k <= matchDim; k++)
+          val += leftArray(i, k) * rightArray(k, j);
+        resultArray(i, j) = val;
+      }
+    }
+  }
+  else
+    throw ModelicaSimulationError(MODEL_ARRAY_FUNCTION,
+                                  "Unsupported dimensions in multiply_array");
+}
+
 template < typename T>
 void divide_array(BaseArray<T>& inputArray, const T &b, BaseArray<T>& outputArray)
@@ -346 +393 @@
 template void BOOST_EXTENSION_EXPORT_DECL multiply_array(BaseArray<bool>& inputArray, const bool &b, BaseArray<bool> & outputArray);
 
+template void BOOST_EXTENSION_EXPORT_DECL multiply_array(const BaseArray<double> &leftArray, const BaseArray<double> &rightArray, BaseArray<double> &resultArray);
+template void BOOST_EXTENSION_EXPORT_DECL multiply_array(const BaseArray<int> &leftArray, const BaseArray<int> &rightArray, BaseArray<int> &resultArray);
+template void BOOST_EXTENSION_EXPORT_DECL multiply_array(const BaseArray<bool> &leftArray, const BaseArray<bool> &rightArray, BaseArray<bool> &resultArray);
+
 template void BOOST_EXTENSION_EXPORT_DECL divide_array(BaseArray<double>& inputArray, const double &b, BaseArray<double>& outputArray);
 template void BOOST_EXTENSION_EXPORT_DECL divide_array(BaseArray<int>& inputArray, const int &b, BaseArray<int>& outputArray);

trunk/SimulationRuntime/cpp/Include/Core/Math/Array.h

@@ -40 +40 @@
   };
 
-  virtual T& operator()(size_t  i, size_t j)
+  virtual T& operator()(size_t i, size_t j)
+  {
+    throw ModelicaSimulationError(MODEL_ARRAY_FUNCTION,"Wrong virtual Array operator call");
+  };
+
+  virtual const T& operator()(size_t i, size_t j) const
   {
     throw ModelicaSimulationError(MODEL_ARRAY_FUNCTION,"Wrong virtual Array operator call");
@@ -1465 +1470 @@
     return _multi_array[i][j];
   }
+  inline virtual const T& operator()(size_t i, size_t j) const
+  {
+    return _multi_array[i][j];
+  }
 
   void setDims(size_t size1, size_t size2)

trunk/SimulationRuntime/cpp/Include/Core/Math/ArrayOperations.h

@@ -44 +44 @@
 void create_array_from_shape(const spec_type& sp,BaseArray<T>& s,BaseArray<T>& d);
 
-
-
 template < typename T >
 void promote_array(unsigned int n,BaseArray<T>& s,BaseArray<T>& d);
-
-
 
 template < typename T>
 void multiply_array( BaseArray<T> & inputArray ,const T &b, BaseArray<T> & outputArray  );
 
+template <typename T>
+void multiply_array(const BaseArray<T> &leftArray, const BaseArray<T> &rightArray, BaseArray<T> &resultArray);
 
 template < typename T>
 void divide_array( BaseArray<T> & inputArray ,const T &b, BaseArray<T> & outputArray  );
-
 
 template < typename T >

trunk/SimulationRuntime/cpp/Include/Core/Math/ArraySlice.h

@@ -252 +252 @@
   }
 
-  virtual T& operator()(size_t  i, size_t j) {
+  virtual T& operator()(size_t i, size_t j) {
+    accessElement(2, i, j);
+  }
+
+  virtual const T& operator()(size_t i, size_t j) const {
     accessElement(2, i, j);
   }