pennylane-qrack 0.21.1__tar.gz → 0.22.0__tar.gz

{pennylane_qrack-0.21.1 → pennylane_qrack-0.22.0}/Makefile

@@ -24,7 +24,7 @@ help:
 build-deps:
 ifneq ($(OS),Windows_NT)
 ifeq ($(QRACK_PRESENT),)
-	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout 9bbd10bbadf800d7604dc73f0315e84180f3939c; cd ..
+	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout 4b2d031d880a9ab3abbcc6dcd7d8a19464e2df89; cd ..
 endif
 	mkdir -p qrack/build
 ifeq ($(UNAME_S),Linux)

{pennylane_qrack-0.21.1 → pennylane_qrack-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pennylane-qrack
-Version: 0.21.1
+Version: 0.22.0
 Summary: PennyLane plugin for Qrack.
 Home-page: http://github.com/vm6502q
 Maintainer: vm6502q
@@ -65,7 +65,8 @@ Features
 
 * Provides access to a PyQrack simulator backend via the ``qrack.simulator`` device
 * Provides access to a (C++) Qrack simulator backend for Catalyst (also) via the ``qrack.simulator`` device
-* Provides access to a PyQrack simulator backend optimized for approximate NISQ-scale TFIM via the ``qrack.ace`` device
+* Provides access to a PyQrack Clifford-only simulator backend via the ``qrack.stabilizer`` device
+* Provides access to a PyQrack simulator backend optimized for large-scale approximate simulation via the ``qrack.ace`` device
 
 .. installation-start-inclusion-marker-do-not-remove
 

{pennylane_qrack-0.21.1 → pennylane_qrack-0.22.0}/README.rst

@@ -22,7 +22,8 @@ Features
 
 * Provides access to a PyQrack simulator backend via the ``qrack.simulator`` device
 * Provides access to a (C++) Qrack simulator backend for Catalyst (also) via the ``qrack.simulator`` device
-* Provides access to a PyQrack simulator backend optimized for approximate NISQ-scale TFIM via the ``qrack.ace`` device
+* Provides access to a PyQrack Clifford-only simulator backend via the ``qrack.stabilizer`` device
+* Provides access to a PyQrack simulator backend optimized for large-scale approximate simulation via the ``qrack.ace`` device
 
 .. installation-start-inclusion-marker-do-not-remove
 

pennylane_qrack-0.22.0/catalyst/runtime/include/DataView.hpp

@@ -0,0 +1,150 @@
+// Copyright 2023 Xanadu Quantum Technologies Inc.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <Exception.hpp>
+
+/**
+ * A multi-dimensional view for MemRef-like and std::vector<T> types.
+ *
+ * @tparam T The underlying data type
+ * @tparam R The Rank (R > 0)
+ *
+ * @note A forward iterator is implemented in this view for traversing over the entire
+ * elements of MemRef types rank-by-rank starting from the last dimension (R-1). For example,
+ * The DataView iterator for MemRef<T, 2> starts from index (0, 0) and traverses elements
+ * in the following order:
+ * (0, 0), ..., (0, sizes[1]-1), (1, 0), ..., (1, sizes[1]-1), ... (sizes[0]-1, sizes[1]-1).
+ */
+template <typename T, size_t R> class DataView {
+  private:
+    T *data_aligned;
+    size_t offset;
+    size_t sizes[R] = {0};
+    size_t strides[R] = {0};
+
+  public:
+    class iterator {
+      private:
+        const DataView<T, R> &view;
+
+        int64_t loc; // physical index
+        size_t indices[R] = {0};
+
+      public:
+        using iterator_category = std::forward_iterator_tag; // LCOV_EXCL_LINE
+        using value_type = T;                                // LCOV_EXCL_LINE
+        using difference_type = std::ptrdiff_t;              // LCOV_EXCL_LINE
+        using pointer = T *;                                 // LCOV_EXCL_LINE
+        using reference = T &;                               // LCOV_EXCL_LINE
+
+        iterator(const DataView<T, R> &_view, int64_t begin_idx) : view(_view), loc(begin_idx) {}
+        pointer operator->() const { return &view.data_aligned[loc]; }
+        reference operator*() const { return view.data_aligned[loc]; }
+        iterator &operator++()
+        {
+            int64_t next_axis = -1;
+            int64_t idx;
+            for (int64_t i = R; i > 0; --i) {
+                idx = i - 1;
+                RT_ASSERT(view.sizes[idx] > 0);
+                if (indices[idx]++ < view.sizes[idx] - 1) {
+                    next_axis = idx;
+                    break;
+                }
+                indices[idx] = 0;
+                loc -= (view.sizes[idx] - 1) * view.strides[idx];
+            }
+
+            loc = next_axis == -1 ? -1 : loc + view.strides[next_axis];
+            return *this;
+        }
+        iterator operator++(int)
+        {
+            auto tmp = *this;
+            int64_t next_axis = -1;
+            int64_t idx;
+            for (int64_t i = R; i > 0; --i) {
+                idx = i - 1;
+                RT_ASSERT(view.sizes[idx] > 0);
+                if (indices[idx]++ < view.sizes[idx] - 1) {
+                    next_axis = idx;
+                    break;
+                }
+                indices[idx] = 0;
+                loc -= (view.sizes[idx] - 1) * view.strides[idx];
+            }
+
+            loc = next_axis == -1 ? -1 : loc + view.strides[next_axis];
+            return tmp;
+        }
+        bool operator==(const iterator &other) const
+        {
+            return (loc == other.loc && view.data_aligned == other.view.data_aligned);
+        }
+        bool operator!=(const iterator &other) const { return !(*this == other); }
+    };
+
+    explicit DataView(std::vector<T> &buffer) : data_aligned(buffer.data()), offset(0)
+    {
+        static_assert(R == 1, "[Class: DataView] Assertion: R == 1");
+        sizes[0] = buffer.size();
+        strides[0] = 1;
+    }
+
+    explicit DataView(T *_data_aligned, size_t _offset, const size_t *_sizes,
+                      const size_t *_strides)
+        : data_aligned(_data_aligned), offset(_offset)
+    {
+        static_assert(R > 0, "[Class: DataView] Assertion: R > 0");
+        if (_sizes != nullptr && _strides != nullptr) {
+            for (size_t i = 0; i < R; i++) {
+                sizes[i] = _sizes[i];
+                strides[i] = _strides[i];
+            }
+        } // else sizes = {0}, strides = {0}
+    }
+
+    [[nodiscard]] auto size() const -> size_t
+    {
+        if (!data_aligned) {
+            return 0;
+        }
+
+        size_t tsize = 1;
+        for (size_t i = 0; i < R; i++) {
+            tsize *= sizes[i];
+        }
+        return tsize;
+    }
+
+    template <typename... I> T &operator()(I... idxs) const
+    {
+        static_assert(sizeof...(idxs) == R,
+                      "[Class: DataView] Error in Catalyst Runtime: Wrong number of indices");
+        size_t indices[] = {static_cast<size_t>(idxs)...};
+
+        size_t loc = offset;
+        for (size_t axis = 0; axis < R; axis++) {
+            RT_ASSERT(indices[axis] < sizes[axis]);
+            loc += indices[axis] * strides[axis];
+        }
+        return data_aligned[loc];
+    }
+
+    iterator begin() { return iterator{*this, static_cast<int64_t>(offset)}; }
+
+    iterator end() { return iterator{*this, -1}; }
+};

pennylane_qrack-0.22.0/catalyst/runtime/include/Exception.hpp

@@ -0,0 +1,87 @@
+// Copyright 2023 Xanadu Quantum Technologies Inc.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <exception>
+#include <iostream>
+
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+/**
+ * @brief Macro that throws `RuntimeException` with given message.
+ */
+#define RT_FAIL(message) Catalyst::Runtime::_abort((message), __FILE__, __LINE__, __func__)
+
+/**
+ * @brief Macro that throws `RuntimeException` if expression evaluates
+ * to true.
+ */
+#define RT_FAIL_IF(expression, message)                                                            \
+    if ((expression)) {                                                                            \
+        RT_FAIL(message);                                                                          \
+    }
+
+/**
+ * @brief Macro that throws `RuntimeException` with the given expression
+ * and source location if expression evaluates to false.
+ */
+#define RT_ASSERT(expression) RT_FAIL_IF(!(expression), "Assertion: " #expression)
+
+namespace Catalyst::Runtime {
+
+/**
+ * @brief This is the general exception thrown by Catalyst for runtime errors
+ * that is derived from `std::exception`.
+ */
+class RuntimeException : public std::exception {
+  private:
+    const std::string err_msg;
+
+  public:
+    explicit RuntimeException(std::string msg) noexcept
+        : err_msg{std::move(msg)} {}        // LCOV_EXCL_LINE
+    ~RuntimeException() override = default; // LCOV_EXCL_LINE
+
+    RuntimeException(const RuntimeException &) = default;
+    RuntimeException(RuntimeException &&) noexcept = default;
+
+    RuntimeException &operator=(const RuntimeException &) = delete;
+    RuntimeException &operator=(RuntimeException &&) = delete;
+
+    [[nodiscard]] auto what() const noexcept -> const char * override
+    {
+        return err_msg.c_str();
+    } // LCOV_EXCL_LINE
+};
+
+/**
+ * @brief Throws a `RuntimeException` with the given error message.
+ *
+ * @note This is not supposed to be called directly.
+ */
+[[noreturn]] inline void _abort(const char *message, const char *file_name, size_t line,
+                                const char *function_name)
+{
+    std::stringstream sstream;
+    sstream << "[" << file_name << ":" << line << "][Function:" << function_name
+            << "] Error in Catalyst Runtime: " << message;
+
+    throw RuntimeException(sstream.str());
+} // LCOV_EXCL_LINE
+
+} // namespace Catalyst::Runtime

pennylane_qrack-0.22.0/catalyst/runtime/include/OQDRuntimeCAPI.h

@@ -0,0 +1,56 @@
+// Copyright 2025 Xanadu Quantum Technologies Inc.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#ifndef OQDRUNTIMECAPI_H
+#define OQDRUNTIMECAPI_H
+
+#include <array>
+#include <cstdint>
+
+#include "Exception.hpp"
+#include "Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct Beam {
+    int64_t transition_index;
+    double rabi;
+    double detuning;
+    std::array<int64_t, 3> polarization;
+    std::array<int64_t, 3> wavevector;
+};
+
+struct Pulse {
+    Beam *beam;
+    size_t target;
+    double duration;
+    double phase;
+};
+
+// OQD Runtime Instructions
+void __catalyst__oqd__rt__initialize();
+void __catalyst__oqd__rt__finalize(const std::string &openapl_file_name);
+void __catalyst__oqd__ion(const std::string &ion_specs);
+void __catalyst__oqd__modes(const std::vector<std::string> &phonon_specs);
+Pulse *__catalyst__oqd__pulse(QUBIT *qubit, double duration, double phase, Beam *beam);
+void __catalyst__oqd__ParallelProtocol(Pulse **pulses, size_t n);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif