mqt-core 3.2.0__cp314-cp314-win_arm64.whl

mqt/core/include/mqt-core/qasm3/passes/ConstEvalPass.hpp

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "qasm3/InstVisitor.hpp"
+#include "qasm3/NestedEnvironment.hpp"
+#include "qasm3/Statement_fwd.hpp"
+#include "qasm3/passes/CompilerPass.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace qasm3::const_eval {
+struct ConstEvalValue {
+  enum Type : uint8_t {
+    ConstInt,
+    ConstUint,
+    ConstFloat,
+    ConstBool,
+  } type;
+  std::variant<int64_t, double, bool> value;
+  size_t width;
+
+  explicit ConstEvalValue(double val, const size_t w = 64)
+      : type(ConstFloat), value(val), width(w) {}
+  explicit ConstEvalValue(int64_t val, const bool isSigned, const size_t w = 64)
+      : type(isSigned ? ConstInt : ConstUint), value(val), width(w) {}
+  explicit ConstEvalValue(bool val) : type(ConstBool), value(val), width(1) {}
+
+  [[nodiscard]] std::shared_ptr<Constant> toExpr() const;
+
+  bool operator==(const ConstEvalValue& rhs) const;
+
+  bool operator!=(const ConstEvalValue& rhs) const { return !(*this == rhs); }
+
+  [[nodiscard]] std::string toString() const;
+};
+
+class ConstEvalPass final
+    : public CompilerPass,
+      public DefaultInstVisitor,
+      public ExpressionVisitor<std::optional<ConstEvalValue>>,
+      public TypeVisitor<std::shared_ptr<Expression>> {
+  NestedEnvironment<ConstEvalValue> env;
+
+public:
+  ConstEvalPass() = default;
+  ~ConstEvalPass() override = default;
+
+  void addConst(const std::string& identifier, const ConstEvalValue& val) {
+    env.emplace(identifier, val);
+  }
+
+  void addConst(const std::string& identifier, const double val) {
+    env.emplace(identifier, ConstEvalValue(val));
+  }
+
+  void processStatement(Statement& statement) override;
+
+  void pushEnv() { env.push(); }
+  void popEnv() { env.pop(); }
+
+  void visitDeclarationStatement(
+      std::shared_ptr<DeclarationStatement> declarationStatement) override;
+  void visitGateCallStatement(
+      std::shared_ptr<GateCallStatement> gateCallStatement) override;
+
+  std::optional<ConstEvalValue> visitBinaryExpression(
+      std::shared_ptr<BinaryExpression> binaryExpression) override;
+  std::optional<ConstEvalValue> visitUnaryExpression(
+      std::shared_ptr<UnaryExpression> unaryExpression) override;
+  std::optional<ConstEvalValue>
+  visitConstantExpression(std::shared_ptr<Constant> constant) override;
+  std::optional<ConstEvalValue> visitIdentifierExpression(
+      std::shared_ptr<IdentifierExpression> identifierExpression) override;
+  std::optional<ConstEvalValue>
+  visitIdentifierList(std::shared_ptr<IdentifierList> identifierList) override;
+  std::optional<ConstEvalValue> visitIndexedIdentifier(
+      std::shared_ptr<IndexedIdentifier> indexedIdentifier) override;
+  std::optional<ConstEvalValue> visitMeasureExpression(
+      std::shared_ptr<MeasureExpression> measureExpression) override;
+
+  std::shared_ptr<ResolvedType> visitDesignatedType(
+      DesignatedType<std::shared_ptr<Expression>>* designatedType) override;
+  std::shared_ptr<ResolvedType> visitUnsizedType(
+      UnsizedType<std::shared_ptr<Expression>>* unsizedType) override;
+  std::shared_ptr<ResolvedType>
+  visitArrayType(ArrayType<std::shared_ptr<Expression>>* arrayType) override;
+};
+} // namespace qasm3::const_eval

mqt/core/include/mqt-core/qasm3/passes/TypeCheckPass.hpp

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "qasm3/InstVisitor.hpp"
+#include "qasm3/Statement_fwd.hpp"
+#include "qasm3/Types.hpp"
+#include "qasm3/passes/CompilerPass.hpp"
+#include "qasm3/passes/ConstEvalPass.hpp"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace qasm3 {
+class GateOperand;
+struct DebugInfo;
+} // namespace qasm3
+
+namespace qasm3::type_checking {
+struct InferredType {
+  bool isError;
+  std::shared_ptr<ResolvedType> type;
+
+  InferredType(const bool isErr, std::shared_ptr<ResolvedType> ty)
+      : isError(isErr), type(std::move(ty)) {}
+
+  explicit InferredType(std::shared_ptr<ResolvedType> ty)
+      : isError(false), type(std::move(ty)) {}
+
+  static InferredType error() { return InferredType{true, nullptr}; }
+
+  [[nodiscard]] bool matches(const InferredType& other) const {
+    if (isError || other.isError) {
+      return true;
+    }
+
+    return *type == *other.type;
+  }
+
+  [[nodiscard]] std::string toString() const {
+    if (isError) {
+      return "error";
+    }
+    return type->toString();
+  }
+};
+
+class TypeCheckPass final : public CompilerPass,
+                            public InstVisitor,
+                            public ExpressionVisitor<InferredType> {
+  bool hasError = false;
+  std::string errMessage;
+  std::map<std::string, InferredType> env;
+  // We need a reference to a const eval pass to evaluate types before type
+  // checking.
+  const_eval::ConstEvalPass* constEvalPass;
+
+  InferredType error(const std::string& msg,
+                     const std::shared_ptr<DebugInfo>& debugInfo = nullptr);
+
+public:
+  explicit TypeCheckPass(const_eval::ConstEvalPass& pass)
+      : constEvalPass(&pass) {}
+
+  ~TypeCheckPass() override = default;
+
+  void addBuiltin(const std::string& identifier, const InferredType& ty) {
+    env.emplace(identifier, ty);
+  }
+
+  void processStatement(Statement& statement) override;
+
+  void checkIndexOperator(const IndexOperator& indexOperator);
+  void checkIndexedIdentifier(const IndexedIdentifier& id);
+  void checkGateOperand(const GateOperand& operand);
+
+  // Types
+  void
+  visitGateStatement(std::shared_ptr<GateDeclaration> gateStatement) override;
+  void visitVersionDeclaration(
+      std::shared_ptr<VersionDeclaration> versionDeclaration) override;
+  void visitDeclarationStatement(
+      std::shared_ptr<DeclarationStatement> declarationStatement) override;
+  void
+  visitInitialLayout(std::shared_ptr<InitialLayout> initialLayout) override;
+  void visitOutputPermutation(
+      std::shared_ptr<OutputPermutation> outputPermutation) override;
+  void visitGateCallStatement(
+      std::shared_ptr<GateCallStatement> gateCallStatement) override;
+  void visitAssignmentStatement(
+      std::shared_ptr<AssignmentStatement> assignmentStatement) override;
+  void visitBarrierStatement(
+      std::shared_ptr<BarrierStatement> barrierStatement) override;
+  void
+  visitResetStatement(std::shared_ptr<ResetStatement> resetStatement) override;
+  void visitIfStatement(std::shared_ptr<IfStatement> ifStatement) override;
+
+  // Expressions
+  InferredType visitBinaryExpression(
+      std::shared_ptr<BinaryExpression> binaryExpression) override;
+  InferredType visitUnaryExpression(
+      std::shared_ptr<UnaryExpression> unaryExpression) override;
+  InferredType
+  visitConstantExpression(std::shared_ptr<Constant> constantInt) override;
+  InferredType visitIdentifierExpression(
+      std::shared_ptr<IdentifierExpression> identifierExpression) override;
+  InferredType
+  visitIdentifierList(std::shared_ptr<IdentifierList> identifierList) override;
+  InferredType visitIndexedIdentifier(
+      std::shared_ptr<IndexedIdentifier> indexedIdentifier) override;
+  InferredType visitMeasureExpression(
+      std::shared_ptr<MeasureExpression> measureExpression) override;
+};
+} // namespace qasm3::type_checking

mqt/core/include/mqt-core/zx/FunctionalityConstruction.hpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "ZXDefinitions.hpp"
+#include "ZXDiagram.hpp"
+#include "ir/Permutation.hpp"
+#include "ir/QuantumComputation.hpp"
+#include "ir/operations/Expression.hpp"
+#include "ir/operations/Operation.hpp"
+
+#include <cstddef>
+#include <optional>
+#include <vector>
+
+namespace zx {
+
+/**
+ * @brief Static class to construct ZX-diagrams from a Quantumcomputation
+ */
+class FunctionalityConstruction {
+  using op_it = qc::QuantumComputation::const_iterator;
+
+public:
+  /**
+   * @brief Builds a ZX-diagram from a QuantumComputation
+   *
+   * @param qc Pointer to QuantumComputation to build the ZX-diagram from
+   * @return ZXDiagram
+   */
+  static ZXDiagram buildFunctionality(const qc::QuantumComputation* qc);
+
+  /**
+   * @brief Check whether a given QuantumComputation can be transformed to a
+   * ZXDiagram.
+   * @details Not all instructions supported by the QuantumComputation are
+   * supported by the ZXDiagram (e.g. arbitrarily-controlled multi-qubit gates).
+   * @param qc Pointer to QuantumComputation to check
+   * @return true if the QuantumComputation can be transformed to a ZXDiagram,
+   * false otherwise
+   */
+  static bool transformableToZX(const qc::QuantumComputation* qc);
+
+  /**
+   * @brief Check whether a given Operation can be transformed to a ZXDiagram.
+   * @details Not all Operations have a corresponding representation in the
+   * ZX-calculus.
+   * @param op Pointer to Operation to check
+   * @return true if the Operation can be transformed to a ZXDiagram, false
+   * otherwise
+   */
+  static bool transformableToZX(const qc::Operation* op);
+
+protected:
+  static bool checkSwap(const op_it& it, const op_it& end, Qubit ctrl,
+                        Qubit target, const qc::Permutation& p);
+  static void addZSpider(ZXDiagram& diag, zx::Qubit qubit,
+                         std::vector<Vertex>& qubits,
+                         const PiExpression& phase = PiExpression(),
+                         EdgeType type = EdgeType::Simple);
+  static void addXSpider(ZXDiagram& diag, Qubit qubit,
+                         std::vector<Vertex>& qubits,
+                         const PiExpression& phase = PiExpression(),
+                         EdgeType type = EdgeType::Simple);
+  static void
+  addRz(ZXDiagram& diag, const PiExpression& phase, Qubit target,
+        std::vector<Vertex>& qubits,
+        const std::optional<double>& unconvertedPhase = std::nullopt);
+  static void addRx(ZXDiagram& diag, const PiExpression& phase, Qubit target,
+                    std::vector<Vertex>& qubits);
+  static void
+  addRy(ZXDiagram& diag, const PiExpression& phase, Qubit target,
+        std::vector<Vertex>& qubits,
+        const std::optional<double>& unconvertedPhase = std::nullopt);
+  static void addCnot(ZXDiagram& diag, Qubit ctrl, Qubit target,
+                      std::vector<Vertex>& qubits,
+                      EdgeType type = EdgeType::Simple);
+  static void addCphase(ZXDiagram& diag, const PiExpression& phase, Qubit ctrl,
+                        Qubit target, std::vector<Vertex>& qubits);
+  static void addSwap(ZXDiagram& diag, Qubit target, Qubit target2,
+                      std::vector<Vertex>& qubits);
+  static void
+  addRzz(ZXDiagram& diag, const PiExpression& phase, Qubit target,
+         Qubit target2, std::vector<Vertex>& qubits,
+         const std::optional<double>& unconvertedPhase = std::nullopt);
+  static void
+  addRxx(ZXDiagram& diag, const PiExpression& phase, Qubit target,
+         Qubit target2, std::vector<Vertex>& qubits,
+         const std::optional<double>& unconvertedPhase = std::nullopt);
+  static void
+  addRzx(ZXDiagram& diag, const PiExpression& phase, Qubit target,
+         Qubit target2, std::vector<Vertex>& qubits,
+         const std::optional<double>& unconvertedPhase = std::nullopt);
+  static void addDcx(ZXDiagram& diag, Qubit qubit1, Qubit qubit2,
+                     std::vector<Vertex>& qubits);
+  static void
+  addXXplusYY(ZXDiagram& diag, const PiExpression& theta,
+              const PiExpression& beta, Qubit qubit0, Qubit qubit1,
+              std::vector<Vertex>& qubits,
+              const std::optional<double>& unconvertedBeta = std::nullopt);
+  static void
+  addXXminusYY(ZXDiagram& diag, const PiExpression& theta,
+               const PiExpression& beta, Qubit qubit0, Qubit qubit1,
+               std::vector<Vertex>& qubits,
+               const std::optional<double>& unconvertedBeta = std::nullopt);
+  static void addCcx(ZXDiagram& diag, Qubit ctrl0, Qubit ctrl1, Qubit target,
+                     std::vector<Vertex>& qubits);
+  static op_it parseOp(ZXDiagram& diag, op_it it, op_it end,
+                       std::vector<Vertex>& qubits, const qc::Permutation& p);
+  static op_it parseCompoundOp(ZXDiagram& diag, op_it it, op_it end,
+                               std::vector<Vertex>& qubits,
+                               const qc::Permutation& initialLayout);
+
+  static PiExpression toPiExpr(const qc::SymbolOrNumber& param);
+  static PiExpression parseParam(const qc::Operation* op, std::size_t i);
+};
+} // namespace zx

mqt/core/include/mqt-core/zx/Rational.hpp

@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#if defined(GMP)
+#include <boost/multiprecision/gmp.hpp> // IWYU pragma: keep
+using Rational = boost::multiprecision::mpq_rational;
+using BigInt = boost::multiprecision::mpz_int;
+#else
+#include <boost/multiprecision/cpp_int.hpp> // IWYU pragma: keep
+#include <boost/multiprecision/fwd.hpp>
+using Rational = boost::multiprecision::cpp_rational;
+using BigInt = boost::multiprecision::cpp_int;
+#endif
+
+#include <boost/multiprecision/rational_adaptor.hpp>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+
+namespace zx {
+
+/*
+ * @brief Representation of fractions as multiples of pi
+ * @details Rationals can only have values in the half-open interval (-1,1],
+ * corresponding to the interval (-pi, pi]
+ */
+class PiRational {
+public:
+  /**
+   * @brief Default constructor initializes the rational to 0/1.
+   */
+  PiRational() = default;
+
+  /**
+   * @brief Construct a PiRational from numerator and denominator.
+   * @details The input fraction is already assumed to be in multiples of Pi.
+   * For example, the fraction 1/2 corresponds to Pi/2.
+   * @param num Numerator of the fraction.
+   * @param denom Denominator of the fraction.
+   */
+  explicit PiRational(int64_t num, int64_t denom) : frac(num, denom) {
+    modPi();
+  }
+  explicit PiRational(const BigInt& num, const BigInt& denom)
+      : frac(num, denom) {
+    modPi();
+  }
+
+  /**
+   * @brief Construct a PiRational from numerator. Denominator is assumed to
+   * be 1.
+   * @details The input numerator is already assumed to be in multiples of Pi.
+   * For example a numerator of 1 corresponds to a fraction Pi/1.
+   * @param num Numerator of the fraction.
+   */
+  explicit PiRational(int64_t num) : frac(num, 1) { modPi(); }
+
+  /**
+   * @brief Construct a PiRational from a double.
+   * @details The input double is approximated as a fraction of Pi within a
+   * tolerance of 1e-13.
+   * @param val Double value to be approximated.
+   */
+  explicit PiRational(double val);
+
+  PiRational& operator+=(const PiRational& rhs);
+  PiRational& operator+=(int64_t rhs);
+
+  PiRational& operator-=(const PiRational& rhs);
+  PiRational& operator-=(int64_t rhs);
+
+  PiRational& operator*=(const PiRational& rhs);
+  PiRational& operator*=(int64_t rhs);
+
+  PiRational& operator/=(const PiRational& rhs);
+  PiRational& operator/=(int64_t rhs);
+
+  /**
+   * @brief Check if the fraction is an integer, i.e., the denominator is 1.
+   * @return True if the fraction is an integer, false otherwise.
+   */
+  [[nodiscard]] bool isInteger() const {
+    return boost::multiprecision::denominator(frac) == 1;
+  }
+
+  /**
+   * @brief Check if the fraction is zero, i,e, the numerator is 0.
+   * @return True if the fraction is zero, false otherwise.
+   */
+  [[nodiscard]] bool isZero() const {
+    return boost::multiprecision::numerator(frac) == 0;
+  }
+
+  /**
+   * @brief Get the denominator of the fraction.
+   * @return Denominator of the fraction.
+   */
+  [[nodiscard]] BigInt getDenom() const {
+    return boost::multiprecision::denominator(frac);
+  }
+
+  /**
+   * @brief Get the numerator of the fraction.
+   * @return Numerator of the fraction.
+   */
+  [[nodiscard]] BigInt getNum() const {
+    return boost::multiprecision::numerator(frac);
+  }
+
+  /**
+   * @brief Convert the fraction to a double.
+   * @details The result is not taken mod Pi. Converting 1/1 will return an
+   * approximation of Pi.
+   * @return Double value of the fraction.
+   */
+  [[nodiscard]] double toDouble() const;
+
+  /**
+   * @brief Convert the fraction to a double mod Pi.
+   * @details The result is taken mod Pi. Converting 1/1 will return 1.0.
+   * @return Double value of the fraction.
+   */
+  [[nodiscard]] double toDoubleDivPi() const {
+    return frac.convert_to<double>();
+  }
+
+  /**
+   * @brief Check if the fraction is close to a double value within a tolerance.
+   * @details The comparison is not done mod Pi. So if the fraction is 1/1
+   * isClose(1.0, 1e-13) will return true.
+   * @param x Double value to compare to.
+   * @param tolerance Tolerance for the comparison.
+   * @return True if the fraction is close to the double value, false otherwise.
+   */
+  [[nodiscard]] bool isClose(const double x, const double tolerance) const {
+    return std::abs(toDouble() - x) < tolerance;
+  }
+
+  /**
+   * @brief Check if the fraction is close to a double value within a tolerance
+   * mod Pi.
+   * @details The comparison is done mod Pi. So if the fraction is 1/1
+   * isCloseDivPi(1.0, 1e-13) will return false, but isCloseDivPi(3.14159,
+   * 1e-14) will return true.
+   * @param x Double value to compare to.
+   * @param tolerance Tolerance for the comparison.
+   * @return True if the fraction is close to the double value divided by Pi,
+   * false otherwise.
+   */
+  [[nodiscard]] bool isCloseDivPi(const double x,
+                                  const double tolerance) const {
+    return std::abs(toDoubleDivPi() - x) < tolerance;
+  }
+
+  /**
+   * @brief Get the double value of the fraction.
+   * @details The result is not taken mod Pi. Converting 1/1 will return 1.0.
+   * @return Double value of the fraction.
+   */
+  explicit operator double() const { return this->toDouble(); }
+
+private:
+  Rational frac;
+
+  void modPi();
+
+  void setNum(const BigInt& num) {
+    boost::multiprecision::numerator(frac) = num;
+  }
+
+  void setDenom(const BigInt& denom) const {
+    boost::multiprecision::denominator(frac) = denom;
+  }
+};
+
+inline PiRational operator-(const PiRational& rhs) {
+  return PiRational(-rhs.getNum(), rhs.getDenom());
+}
+inline PiRational operator+(PiRational lhs, const PiRational& rhs) {
+  lhs += rhs;
+  return lhs;
+}
+inline PiRational operator+(PiRational lhs, const int64_t rhs) {
+  lhs += rhs;
+  return lhs;
+}
+inline PiRational operator+(const int64_t lhs, PiRational rhs) {
+  rhs += lhs;
+  return rhs;
+}
+
+inline PiRational operator-(PiRational lhs, const PiRational& rhs) {
+  lhs -= rhs;
+  return lhs;
+}
+inline PiRational operator-(PiRational lhs, const int64_t rhs) {
+  lhs -= rhs;
+  return lhs;
+}
+inline PiRational operator-(const int64_t lhs, PiRational rhs) {
+  rhs -= lhs;
+  return rhs;
+}
+
+inline PiRational operator*(PiRational lhs, const PiRational& rhs) {
+  lhs *= rhs;
+  return lhs;
+}
+inline PiRational operator*(PiRational lhs, const int64_t rhs) {
+  lhs *= rhs;
+  return lhs;
+}
+inline PiRational operator*(const int64_t lhs, PiRational rhs) {
+  rhs *= lhs;
+  return rhs;
+}
+
+inline PiRational operator/(PiRational lhs, const PiRational& rhs) {
+  lhs /= rhs;
+  return lhs;
+}
+inline PiRational operator/(PiRational lhs, const int64_t rhs) {
+  lhs /= rhs;
+  return lhs;
+}
+inline PiRational operator/(const int64_t lhs, PiRational rhs) {
+  rhs /= lhs;
+  return rhs;
+}
+
+inline bool operator<(const PiRational& lhs, const PiRational& rhs) {
+  return (lhs.getNum() * rhs.getDenom()) < (rhs.getNum() * lhs.getDenom());
+}
+
+inline bool operator<(const PiRational& lhs, const int64_t rhs) {
+  return lhs.getNum() < (rhs * lhs.getDenom());
+}
+
+inline bool operator<(const int64_t lhs, const PiRational& rhs) {
+  return (lhs * rhs.getDenom()) < rhs.getNum();
+}
+
+inline bool operator<=(const PiRational& lhs, const PiRational& rhs) {
+  return (lhs.getNum() * rhs.getDenom()) <= (rhs.getNum() * lhs.getDenom());
+}
+
+inline bool operator<=(const PiRational& lhs, const int64_t rhs) {
+  return lhs.getNum() <= (rhs * lhs.getDenom());
+}
+
+inline bool operator<=(const int64_t lhs, const PiRational& rhs) {
+  return (lhs * rhs.getDenom()) <= rhs.getNum();
+}
+
+inline bool operator>(const PiRational& lhs, const PiRational& rhs) {
+  return rhs < lhs;
+}
+
+inline bool operator>(const PiRational& lhs, const int64_t rhs) {
+  return rhs < lhs;
+}
+
+inline bool operator>(const int64_t lhs, const PiRational& rhs) {
+  return rhs < lhs;
+}
+
+inline bool operator>=(const PiRational& lhs, const PiRational& rhs) {
+  return rhs <= lhs;
+}
+
+inline bool operator>=(const PiRational& lhs, const int64_t rhs) {
+  return rhs <= lhs;
+}
+
+inline bool operator>=(const int64_t lhs, const PiRational& rhs) {
+  return rhs <= lhs;
+}
+
+inline bool operator==(const PiRational& lhs, const PiRational& rhs) {
+  return lhs.getNum() == rhs.getNum() && lhs.getDenom() == rhs.getDenom();
+}
+
+inline bool operator==(const PiRational& lhs, const int64_t rhs) {
+  return lhs.getNum() == rhs && lhs.getDenom() == 1;
+}
+
+inline bool operator==(const int64_t lhs, const PiRational& rhs) {
+  return rhs == lhs;
+}
+
+inline bool operator!=(const PiRational& lhs, const PiRational& rhs) {
+  return !(lhs == rhs);
+}
+
+inline bool operator!=(const PiRational& lhs, const int64_t rhs) {
+  return !(lhs == rhs);
+}
+
+inline bool operator!=(const int64_t lhs, const PiRational& rhs) {
+  return !(lhs == rhs);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const zx::PiRational& rhs) {
+  os << rhs.getNum() << "/" << rhs.getDenom();
+  return os;
+}
+
+} // namespace zx