✨ added state preparation routines for GHZ and W state

include/dd/Package.hpp

@@ -485,6 +485,74 @@ template <class Config> class Package {
     return f;
   }
 
+  // generate general GHZ state with n qubits
+  vEdge makeGHZState(const std::size_t n) {
+    if (n > nqubits) {
+      throw std::runtime_error{
+          "Requested state with " + std::to_string(n) +
+          " qubits, but current package configuration only supports up to " +
+          std::to_string(nqubits) +
+          " qubits. Please allocate a larger package instance."};
+    }
+
+    if (n == 0U) {
+      return vEdge::one();
+    }
+
+    auto leftSubtree = vEdge::one();
+    auto rightSubtree = vEdge::one();
+
+    for (std::size_t p = 0; p < n - 1; ++p) {
+      leftSubtree = makeDDNode(static_cast<Qubit>(p),
+                               std::array{leftSubtree, vEdge::zero()});
+      rightSubtree = makeDDNode(static_cast<Qubit>(p),
+                                std::array{vEdge::zero(), rightSubtree});
+    }
+
+    return makeDDNode(
+        static_cast<Qubit>(n - 1),
+        std::array<vEdge, RADIX>{
+            {{leftSubtree.p, {&constants::sqrt2over2, &constants::zero}},
+             {rightSubtree.p, {&constants::sqrt2over2, &constants::zero}}}});
+  }
+
+  // generate general W state with n qubits
+  vEdge makeWState(const std::size_t n) {
+    if (n > nqubits) {
+      throw std::runtime_error{
+          "Requested state with " + std::to_string(n) +
+          " qubits, but current package configuration only supports up to " +
+          std::to_string(nqubits) +
+          " qubits. Please allocate a larger package instance."};
+    }
+
+    if (n == 0U) {
+      return vEdge::one();
+    }
+
+    auto leftSubtree = vEdge::zero();
+    if ((1. / sqrt(static_cast<double>(n))) < RealNumber::eps) {
+      throw std::runtime_error(
+          "Requested qubit size for generating W-state would lead to an "
+          "underflow due to 1 / sqrt(n) being smaller than the currently set "
+          "tolerance " +
+          std::to_string(RealNumber::eps) +
+          ". If you still wanna run the computation, please lower "
+          "the tolerance accordingly.");
+    }
+
+    auto rightSubtree = vEdge::terminal(cn.lookup(1. / std::sqrt(n)));
+    for (size_t p = 0; p < n; ++p) {
+      leftSubtree = makeDDNode(static_cast<Qubit>(p),
+                               std::array{leftSubtree, rightSubtree});
+      if (p != n - 1U) {
+        rightSubtree = makeDDNode(static_cast<Qubit>(p),
+                                  std::array{rightSubtree, vEdge::zero()});
+      }
+    }
+    return leftSubtree;
+  }
+
   // generate the decision diagram from an arbitrary state vector
   vEdge makeStateFromVector(const CVec& stateVector) {
     if (stateVector.empty()) {

test/algorithms/test_entanglement.cpp

@@ -1,5 +1,6 @@
 #include "algorithms/Entanglement.hpp"
 #include "dd/FunctionalityConstruction.hpp"
+#include "dd/Simulation.hpp"
 
 #include "gtest/gtest.h"
 #include <string>
@@ -33,3 +34,23 @@ TEST_P(Entanglement, FunctionTest) {
   ASSERT_EQ(r.getValueByPath(std::string(nq, '0')), dd::SQRT2_2);
   ASSERT_EQ(r.getValueByPath(std::string(nq, '1')), dd::SQRT2_2);
 }
+
+TEST_P(Entanglement, GHZRoutineFunctionTest) {
+  const auto nq = GetParam();
+
+  auto qc = qc::Entanglement(nq);
+  auto dd = std::make_unique<dd::Package<>>(nq);
+  const dd::VectorDD e = simulate(&qc, dd->makeZeroState(qc.getNqubits()), dd);
+  const auto f = dd->makeGHZState(nq);
+
+  EXPECT_EQ(e, f);
+}
+
+TEST(Entanglement, GHZStateEdgeCasesTest) {
+  auto dd = std::make_unique<dd::Package<>>(3);
+
+  EXPECT_EQ(dd->makeGHZState(0),
+            dd->makeBasisState(0, {dd::BasisStates::zero}));
+  EXPECT_EQ(dd->makeGHZState(0), dd->makeBasisState(0, {dd::BasisStates::one}));
+  ASSERT_THROW(dd->makeGHZState(6), std::runtime_error);
+}

test/algorithms/test_wstate.cpp

@@ -40,3 +40,25 @@ TEST_P(WState, FunctionTest) {
     EXPECT_TRUE(measurements.find(result) != measurements.end());
   }
 }
+
+TEST_P(WState, RoutineFunctionTest) {
+  const auto nq = GetParam();
+
+  auto qc = qc::WState(nq);
+  auto dd = std::make_unique<dd::Package<>>(qc.getNqubits());
+  const dd::VectorDD e = simulate(&qc, dd->makeZeroState(qc.getNqubits()), dd);
+  const auto f = dd->makeWState(nq);
+
+  EXPECT_EQ(e, f);
+}
+
+TEST(WState, WStateEdgeCasesTest) {
+  auto dd = std::make_unique<dd::Package<>>(101);
+  dd::ComplexNumbers::setTolerance(0.1);
+
+  ASSERT_THROW(dd->makeWState(101), std::runtime_error);
+  EXPECT_EQ(dd->makeWState(0), dd->makeBasisState(0, {dd::BasisStates::zero}));
+  EXPECT_EQ(dd->makeWState(0), dd->makeBasisState(0, {dd::BasisStates::one}));
+  EXPECT_EQ(dd->makeWState(1), dd->makeBasisState(1, {dd::BasisStates::one}));
+  ASSERT_THROW(dd->makeWState(127), std::runtime_error);
+}