Updated pyqpp

vsoftco · vsoftco · commit 6b2d6bc7dd2b · 2025-12-18T19:49:16.000-05:00
Signed-off-by: Vlad Gheorghiu &lt;vsoftco@gmail.com&gt;
diff --git a/pyqpp/include/pyqpp/classes/gates_bind.hpp b/pyqpp/include/pyqpp/classes/gates_bind.hpp
@@ -24,12 +24,16 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/classes/gates_bind.hpp>
+ * \brief Bindings for <qpp/classes/gates.hpp>
+ */
+
 #ifndef PYQPP_CLASSES_GATES_BIND_HPP_
 #define PYQPP_CLASSES_GATES_BIND_HPP_
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* qpp::Gates */
 inline void init_classes_gates(py::module_& m) {
     using namespace qpp;
 
diff --git a/pyqpp/include/pyqpp/classes/qcircuit_bind.hpp b/pyqpp/include/pyqpp/classes/qcircuit_bind.hpp
@@ -24,6 +24,11 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/classes/qcircuit_bind.hpp>
+ * \brief Bindings for <qpp/classes/qcircuit.hpp>
+ */
+
 #ifndef PYQPP_CLASSES_QCIRCUIT_BIND_HPP_
 #define PYQPP_CLASSES_QCIRCUIT_BIND_HPP_
 
@@ -34,9 +39,8 @@
 
 namespace {
 
-class WhileContext
-{
-public:
+class WhileContext {
+  public:
     ~WhileContext() = default;
     WhileContext(WhileContext&&) = default;
 
@@ -45,11 +49,11 @@ class WhileContext
 
     py::object enter();
 
-    bool exit(std::optional<pybind11::type> const&   /* exc_type */,
+    bool exit(std::optional<pybind11::type> const& /* exc_type */,
               std::optional<pybind11::object> const& /* exc_value */,
               std::optional<pybind11::object> const& /* traceback */);
 
-private:
+  private:
     qpp::QCircuit& managed;
 
     explicit WhileContext(qpp::QCircuit& qc) : managed(qc) {}
@@ -59,8 +63,7 @@ class WhileContext
     WhileContext& operator=(WhileContext const&) = delete;
 };
 
-WhileContext WhileContext::pyCreate(qpp::QCircuit& qc, qpp::cond_pred_t pred)
-{
+WhileContext WhileContext::pyCreate(qpp::QCircuit& qc, qpp::cond_pred_t pred) {
     qc.cond_while(pred);
     return WhileContext(qc);
 }
@@ -72,13 +75,12 @@ py::object WhileContext::enter() {
 
 bool WhileContext::exit(std::optional<pybind11::type> const&,
                         std::optional<pybind11::object> const&,
-                        std::optional<pybind11::object> const&)
-{
+                        std::optional<pybind11::object> const&) {
     managed.cond_end();
     return false; // do not supress exceptions that occurred
 }
 
-} /* anonymous namespace (for context managers in Python wrapping) */
+} // namespace
 
 /* qpp::QCircuit and related free functions */
 inline void init_classes_qcircuit(py::module_& m) {
@@ -124,7 +126,7 @@ inline void init_classes_qcircuit(py::module_& m) {
     // wrap context manager
     auto pyWhileContext = py::class_<WhileContext>(m, "CondWhile");
     pyWhileContext.def("__enter__", &WhileContext::enter)
-                  .def("__exit__", &WhileContext::exit);
+        .def("__exit__", &WhileContext::exit);
 
     pyQCircuit.def("cond_while_ctx", &WhileContext::pyCreate,
                    "Adds conditional while context", py::arg("pred"));
diff --git a/pyqpp/include/pyqpp/classes/qdummy_engine_bind.hpp b/pyqpp/include/pyqpp/classes/qdummy_engine_bind.hpp
@@ -24,6 +24,11 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/classes/qdummy_engine_bind.hpp>
+ * \brief Bindings for <qpp/classes/qdummy_engine.hpp>
+ */
+
 #ifndef PYQPP_CLASSES_QDUMMY_ENGINE_BIND_HPP_
 #define PYQPP_CLASSES_QDUMMY_ENGINE_BIND_HPP_
 
diff --git a/pyqpp/include/pyqpp/classes/qengine_bind.hpp b/pyqpp/include/pyqpp/classes/qengine_bind.hpp
@@ -24,6 +24,11 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/classes/qengine_bind.hpp>
+ * \brief Bindings for <qpp/classes/qengine.hpp>
+ */
+
 #ifndef PYQPP_CLASSES_QENGINE_BIND_HPP_
 #define PYQPP_CLASSES_QENGINE_BIND_HPP_
 
diff --git a/pyqpp/include/pyqpp/classes/qnoisy_engine_bind.hpp b/pyqpp/include/pyqpp/classes/qnoisy_engine_bind.hpp
@@ -24,6 +24,11 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/classes/qnoisy_engine_bind.hpp>
+ * \brief Bindings for <qpp/classes/qnoisy_engine.hpp>
+ */
+
 #ifndef PYQPP_CLASSES_QNOISY_ENGINE_BIND_HPP_
 #define PYQPP_CLASSES_QNOISY_ENGINE_BIND_HPP_
 
diff --git a/pyqpp/include/pyqpp/classes/reversible_bind.hpp b/pyqpp/include/pyqpp/classes/reversible_bind.hpp
@@ -24,6 +24,11 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/classes/reversible_bind.hpp>
+ * \brief Bindings for <qpp/classes/reversible.hpp>
+ */
+
 #ifndef PYQPP_CLASSES_REVERSIBLE_BIND_HPP_
 #define PYQPP_CLASSES_REVERSIBLE_BIND_HPP_
 
diff --git a/pyqpp/include/pyqpp/classes/states_bind.hpp b/pyqpp/include/pyqpp/classes/states_bind.hpp
@@ -24,12 +24,16 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/classes/states_bind.hpp>
+ * \brief Bindings for <qpp/classes/states.hpp>
+ */
+
 #ifndef PYQPP_CLASSES_STATES_BIND_HPP_
 #define PYQPP_CLASSES_STATES_BIND_HPP_
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* qpp::States */
 inline void init_classes_states(py::module_& m) {
     using namespace qpp;
 
diff --git a/pyqpp/include/pyqpp/constants_bind.hpp b/pyqpp/include/pyqpp/constants_bind.hpp
@@ -24,12 +24,16 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/constants_bind.hpp>
+ * \brief Bindings for <qpp/constants.hpp>
+ */
+
 #ifndef PYQPP_CONSTANTS_BIND_HPP_
 #define PYQPP_CONSTANTS_BIND_HPP_
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* Bindings for constants.hpp */
 inline void init_constants(py::module_& m) {
     using namespace qpp;
 
diff --git a/pyqpp/include/pyqpp/entanglement_bind.hpp b/pyqpp/include/pyqpp/entanglement_bind.hpp
@@ -24,12 +24,16 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/entanglement_bind.hpp>
+ * \brief Bindings for <qpp/entanglement.hpp>
+ */
+
 #ifndef PYQPP_ENTANGLEMENT_BIND_HPP_
 #define PYQPP_ENTANGLEMENT_BIND_HPP_
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* Bindings for entropies.hpp */
 inline void init_entanglement(py::module_& m) {
     using namespace qpp;
 
diff --git a/pyqpp/include/pyqpp/entropies_bind.hpp b/pyqpp/include/pyqpp/entropies_bind.hpp
@@ -24,12 +24,16 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/entropies_bind.hpp>
+ * \brief Bindings for <qpp/entropies.hpp>
+ */
+
 #ifndef PYQPP_ENTROPIES_BIND_HPP_
 #define PYQPP_ENTROPIES_BIND_HPP_
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* Bindings for entropies.hpp */
 inline void init_entropies(py::module_& m) {
     using namespace qpp;
 
diff --git a/pyqpp/include/pyqpp/functions_bind.hpp b/pyqpp/include/pyqpp/functions_bind.hpp
@@ -24,12 +24,16 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/functions_bind.hpp>
+ * \brief Bindings for <qpp/functions.hpp>
+ */
+
 #ifndef PYQPP_FUNCTIONS_BIND_HPP_
 #define PYQPP_FUNCTIONS_BIND_HPP_
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* Some free functions (non-exhaustive list) from functions.hpp */
 inline void init_functions(py::module_& m) {
     using namespace qpp;
 
diff --git a/pyqpp/include/pyqpp/instruments_bind.hpp b/pyqpp/include/pyqpp/instruments_bind.hpp
@@ -24,12 +24,16 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/instruments_bind.hpp>
+ * \brief Bindings for <qpp/instruments.hpp>
+ */
+
 #ifndef PYQPP_INSTRUMENTS_BIND_HPP_
 #define PYQPP_INSTRUMENTS_BIND_HPP_
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* Bindings for instruments.hpp */
 inline void init_instruments(py::module_& m) {
     using namespace qpp;
 
diff --git a/pyqpp/include/pyqpp/operations_bind.hpp b/pyqpp/include/pyqpp/operations_bind.hpp
@@ -24,12 +24,16 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/operations_bind.hpp>
+ * \brief Bindings for <qpp/operations.hpp>
+ */
+
 #ifndef PYQPP_OPERATIONS_BIND_HPP_
 #define PYQPP_OPERATIONS_BIND_HPP_
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* Bindings for operations.hpp */
 inline void init_operations(py::module_& m) {
     using namespace qpp;
 
diff --git a/pyqpp/include/pyqpp/qasm/qasm_bind.hpp b/pyqpp/include/pyqpp/qasm/qasm_bind.hpp
@@ -24,6 +24,11 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/qasm/qasm_bind.hpp>
+ * \brief Bindings for <qpp/qasm/qasm.hpp>
+ */
+
 #ifndef PYQPP_QASM_QASM_BIND_HPP_
 #define PYQPP_QASM_QASM_BIND_HPP_
 
diff --git a/pyqpp/include/pyqpp/random_bind.hpp b/pyqpp/include/pyqpp/random_bind.hpp
@@ -24,12 +24,16 @@
  * SOFTWARE.
  */
 
+/**
+ * \file <pyqpp/random_bind.hpp>
+ * \brief Bindings for <qpp/random.hpp>
+ */
+
 #ifndef PYQPP_RANDOM_BIND_HPP_
 #define PYQPP_RANDOM_BIND_HPP_
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* Some free functions (non-exhaustive list) from random.hpp */
 inline void init_random(py::module_& m) {
     using namespace qpp;
 
diff --git a/pyqpp/include/pyqpp/statistics_bind.hpp b/pyqpp/include/pyqpp/statistics_bind.hpp
@@ -0,0 +1,99 @@
+/*
+ * This file is part of pyqpp.
+ *
+ * Copyright (c) 2017 - 2025 softwareQ Inc. All rights reserved.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * \file <pyqpp/statistics_bind.hpp>
+ * \brief Bindings for <qpp/statistics.hpp>
+ */
+
+#ifndef PYQPP_STATISTICS_BIND_HPP_
+#define PYQPP_STATISTICS_BIND_HPP_
+
+#include "pyqpp/pyqpp_common.hpp"
+
+/* Bindings for <qpp/statistics.hpp> */
+inline void init_statistics(py::module_& m) {
+    using namespace qpp;
+    // --- Probability Distributions ---
+
+    m.def("uniform", &qpp::uniform,
+          "Generates a uniform probability distribution vector of size N.",
+          py::arg("N"));
+
+    m.def("marginalX", &qpp::marginalX,
+          "Computes the marginal distribution of X from a joint probability "
+          "matrix.",
+          py::arg("probXY"));
+
+    m.def("marginalY", &qpp::marginalY,
+          "Computes the marginal distribution of Y from a joint probability "
+          "matrix.",
+          py::arg("probXY"));
+
+    // --- Statistical Moments ---
+
+    m.def(
+        "avg",
+        [](const std::vector<realT>& prob, const std::vector<realT>& X) {
+            return qpp::avg(prob, X);
+        },
+        "Computes the average E[X] = sum(p_i * x_i).", py::arg("prob"),
+        py::arg("X"));
+
+    m.def(
+        "var",
+        [](const std::vector<realT>& prob, const std::vector<realT>& X) {
+            return qpp::var(prob, X);
+        },
+        "Computes the variance of random variable X.", py::arg("prob"),
+        py::arg("X"));
+
+    m.def(
+        "sigma",
+        [](const std::vector<realT>& prob, const std::vector<realT>& X) {
+            return qpp::sigma(prob, X);
+        },
+        "Computes the standard deviation of random variable X.",
+        py::arg("prob"), py::arg("X"));
+
+    // --- Multivariate Statistics ---
+
+    m.def(
+        "cov",
+        [](const rmat& probXY, const std::vector<realT>& X,
+           const std::vector<realT>& Y) { return qpp::cov(probXY, X, Y); },
+        "Computes the covariance of random variables X and Y.",
+        py::arg("probXY"), py::arg("X"), py::arg("Y"));
+
+    m.def(
+        "cor",
+        [](const rmat& probXY, const std::vector<realT>& X,
+           const std::vector<realT>& Y) { return qpp::cor(probXY, X, Y); },
+        "Computes the correlation coefficient of random variables X and Y.",
+        py::arg("probXY"), py::arg("X"), py::arg("Y"));
+}
+
+#endif /* PYQPP_STATISTICS_BIND_HPP_ */
diff --git a/pyqpp/include/pyqpp/types_bind.hpp b/pyqpp/include/pyqpp/types_bind.hpp
diff --git a/pyqpp/src/pyqpp.cpp b/pyqpp/src/pyqpp.cpp
