cleanup

Author: taminob

mlir/include/mlir/Dialect/Common/IR/CommonTraits.h

@@ -13,47 +13,35 @@
 #include <array>
 #include <cmath>
 #include <cstddef>
+#include <functional>
 #include <mlir/IR/OpDefinition.h>
 #include <mlir/IR/Operation.h>
 #include <mlir/Support/LLVM.h>
 #include <stdexcept>
 
 namespace mqt::ir::common {
-struct DefinitionMatrixElement {
-  enum class Type {
-    Value,
-    ParameterIndex,
-  };
-  enum class Transformation {
-    Identity,
-    Sin,
-    Cos,
-  };
 
-  double value;
-  Type type;
-  Transformation transformation = Transformation::Identity;
+template <std::size_t NumQubits> struct DefinitionMatrix {
+  static constexpr std::size_t MatrixSize = 1 << NumQubits;
+
+  template<typename T>
+  using MatrixType = std::array<T, MatrixSize * MatrixSize>;
 
-  double operator()() {
-    if (type == Type::Value) {
-      switch (transformation) {
-      case Transformation::Identity:
-        return value;
-      case Transformation::Sin:
-        return std::sin(value);
-      case Transformation::Cos:
-        return std::cos(value);
-      }
-      return value;
-    } else {
-      // TODO
-    }
+  MatrixType<double(*)(mlir::ValueRange)> matrix;
+
+  static constexpr std::size_t index(std::size_t x, std::size_t y) {
+    return (y * MatrixSize) + x;
   }
-};
 
-template <std::size_t NumQubits> struct DefinitionMatrix {
-  static constexpr std::size_t MatrixSize = 1 << NumQubits;
-  std::array<double(*)(mlir::ValueRange), MatrixSize * MatrixSize> matrix;
+  constexpr MatrixType<double> getMatrix(mlir::ValueRange params) {
+    // TODO? lazy-initialized cache
+    MatrixType<double> result;
+    static_assert(result.size() == matrix.size());
+    for (std::size_t i = 0; i < result.size(); ++i) {
+      result[i] = matrix[i](params);
+    }
+    return result;
+  }
 };
 
 template <size_t N, DefinitionMatrix<N> Matrix> class TargetArityTrait {
@@ -70,11 +58,15 @@ template <size_t N, DefinitionMatrix<N> Matrix> class TargetArityTrait {
       return mlir::success();
     }
 
-    [[nodiscard]] static auto getDefinitionMatrix() { return Matrix; }
-    [[nodiscard]] static double getDefinitionMatrix(mlir::Operation* op, int x,
-                                                    int y) {
-      return 0.0;
-      // return Matrix[y * (1 << N) + x]();
+    [[nodiscard]] static auto getDefinitionMatrix() {
+      return Matrix;
+    }
+    [[nodiscard]] static auto getDefinitionMatrix(mlir::Operation* op) {
+      auto concreteOp = mlir::cast<ConcreteOp>(op);
+      return Matrix.getMatrix(concreteOp.getParams());
+    }
+    [[nodiscard]] static double getDefinitionMatrixElement(mlir::Operation* op, std::size_t x, std::size_t y) {
+      return getDefinitionMatrix(op).at(DefinitionMatrix<N>::index(x, y));
     }
   };
 };