17303326492

Committed 28 Aug 2025 05:28PM UTC coverage: 89.69% (-3.3%) from 92.994%

Build # 17303326492

Build Type

Pull #8

github

Committed by

web-flow

Commit Message

Merge ae15d8c86 into a58930335

Pull Request Pull Request #8: Optimize the library

Coverage Stats

289 of 378 branches covered (76.46%)

Branch coverage included in aggregate %.

554 of 612 new or added lines in 11 files covered. (90.52%)

4 existing lines in 1 file now uncovered.

1042 of 1106 relevant lines covered (94.21%)

33827.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.99

/include/observable.hpp

#ifndef PP_OBSERVABLE_HPP
#define PP_OBSERVABLE_HPP

#include "pauli.hpp"
#include "pauli_term.hpp"
#include "pauli_term_container.hpp"
#include "merge.hpp"

#include <algorithm>
#include <cstring>
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <ostream>
#include <stdexcept>
#include <string_view>
#include <type_traits>
#include <unordered_map>
#include <vector>

/**
 * @brief Represents a quantum observable as a linear combination of Pauli strings.
 * @tparam T The numeric type for the coefficients (e.g., float, double).
 *
 * An `Observable` is a sum of `PauliTerm` objects, each consisting of a Pauli
 * string and a coefficient. This class is the central data structure in the
 * Pauli back-propagation simulation. Quantum gates are applied to this object,
 * evolving it backward in the Heisenberg picture.
 */
template <typename T = coeff_t>
class Observable {
    public:
        /**
         * @brief Constructs an observable from a single Pauli string.
         * @param pauli_string A string representing the Pauli operators (e.g., "IXYZ").
         * @param coeff The coefficient of this Pauli term.
         *
         * @snippet tests/snippets/observable.cpp observable_from_string
         */
        Observable(std::string_view pauli_string,
                   typename std::enable_if_t<std::is_convertible_v<T, coeff_t>, T> coeff = T{ 1 })
                : paulis_{ PauliTerm<T>(pauli_string, coeff) } {
                check_invariant();
        }

        /**
         * @brief Constructs an observable from a list of Pauli strings.
         * @param pauli_string_list An initializer list of Pauli strings. Each will have a coefficient of 1.
         *
         * @snippet tests/snippets/observable.cpp observable_from_string_list
         */
        Observable(std::initializer_list<std::string_view> pauli_string_list) : paulis_{ pauli_string_list } {
                check_invariant();
        }

        /**
         * @brief Constructs an observable from a list of PauliTerm objects.
         * @param paulis_list An initializer list of `PauliTerm` objects.
         *
         * @snippet tests/snippets/observable.cpp observable_from_pauli_terms
         */
        Observable(std::initializer_list<PauliTerm<T>> paulis_list) : paulis_{ paulis_list } { check_invariant(); }

        /**
         * @brief Constructs an observable from a range of PauliTerm objects.
         * @tparam Iter An iterator type.
         * @param begin An iterator to the beginning of the range.
         * @param end An iterator to the end of the range.
         *
         * @snippet tests/snippets/observable.cpp observable_from_iterators
         */
        template <PauliTermIterator Iter>
        Observable(Iter&& begin, Iter&& end) : paulis_{ begin, end } {
                check_invariant();
        }

        /**
         * @brief Applies a single-qubit Pauli gate to the observable.
         * @param g The Pauli gate to apply.
         * @param qubit The index of the qubit to apply the gate to.
         * @pre qubit index must be less than the number of qubits in the observable.
         */
        void apply_pauli(Pauli_gates g, unsigned qubit) {
                check_qubit(qubit);
                for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {
                        paulis_[i].apply_pauli(g, qubit);
                }
        }

        /**
         * @brief Applies a single-qubit Clifford gate to the observable.
         * @param g The Clifford gate to apply (e.g., Hadamard).
         * @param qubit The index of the qubit to apply the gate to.
         * @pre qubit index must be less than the number of qubits in the observable.
         */
        void apply_clifford(Clifford_Gates_1Q g, unsigned qubit) {
                check_qubit(qubit);
                for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {
                        paulis_[i].apply_clifford(g, qubit);
                }
        }

        /**
         * @brief Applies a single-qubit unital noise channel to the observable.
         * @param n The type of unital noise (e.g., Depolarizing, Dephasing).
         * @param qubit The index of the qubit to apply the noise to.
         * @param p The noise probability parameter.
         * @pre qubit index must be less than the number of qubits in the observable.
         */
        void apply_unital_noise(UnitalNoise n, unsigned qubit, T p) {
                check_qubit(qubit);
                for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {
                        paulis_[i].apply_unital_noise(n, qubit, p);
                }
        }

        /**
         * @brief Applies a CNOT (CX) gate to the observable.
         * @param qubit_control The index of the control qubit.
         * @param qubit_target The index of the target qubit.
         * @pre qubits indexes must be less than the number of qubits in the observable.
         * @pre control qubit != target qubit
         */
        void apply_cx(unsigned qubit_control, unsigned qubit_target) {
                check_qubit(qubit_control);
                check_qubit(qubit_target);
                if (qubit_control == qubit_target) {
                        throw std::invalid_argument("cx gate target must be != from control.");
                }

                for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {
                        paulis_[i].apply_cx(qubit_control, qubit_target);
                }
        }

        /**
         * @brief Applies a single-qubit Rz rotation gate to the observable.
         * @param qubit The index of the qubit to apply the rotation to.
         * @param theta The rotation angle in radians.
         *
         * @note This is a "splitting" operation. Applying an Rz gate to a Pauli term
         * containing an X or Y operator on the target qubit will result in two
         * output Pauli terms, potentially doubling the size of the observable.
         */
        void apply_rz(unsigned qubit, T theta) {
                check_qubit(qubit);

                const auto nb_terms = paulis_.nb_terms();
                // paulis_.reserve(nb_terms * 2);
                for (std::size_t i = 0; i < nb_terms; ++i) {
                        auto p = paulis_[i];
                        if (!p.get_pauli(qubit).commutes_with(p_z)) {
                                auto new_path = paulis_.duplicate_pauliterm(i);
                                paulis_[i].apply_rz(qubit, theta, new_path);
                        }
                }
        }

        /**
         * @brief Applies an amplitude damping noise channel.
         * @param qubit The index of the qubit to apply the channel to.
         * @param pn The noise probability parameter.
         *
         * @note This can be a "splitting" operation. If the Pauli term has a Z operator
         * on the target qubit, the term will be split into two. If it has X or Y, the
         * coefficient is simply scaled. If it has I, there is no effect.
         */
        void apply_amplitude_damping(unsigned qubit, T pn) {
                check_qubit(qubit);
                // paulis_.reserve(paulis_.size() * 2);
                const auto nb_terms = paulis_.nb_terms();
                for (std::size_t i = 0; i < nb_terms; ++i) {
                        auto p = paulis_[i];
                        if (p.get_pauli(qubit) == p_z) {
                                auto new_path = paulis_.duplicate_pauliterm(i); // invalidate p
                                paulis_[i].apply_amplitude_damping_z(qubit, pn, new_path);
                        } else if (p.get_pauli(qubit) == p_x || p.get_pauli(qubit) == p_y) {
                                p.apply_amplitude_damping_xy(qubit, pn);
                        }
                }
        }

        /**
         * @brief Calculates the expectation value of the observable.
         * @return The expectation value.
         *
         * The expectation value is calculated by summing the coefficients of all Pauli terms
         * that commute with Z on all qubits (i.e., contain only I and Z operators).
         */
        T expectation_value() const {
                T ret = 0;
                for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {
                        ret += paulis_[i].expectation_value();
                }
                return ret;
        }

        /** @brief Accesses a specific PauliTerm in the observable. */
        auto operator[](std::size_t idx) { return paulis_[idx]; }
        /** @brief Accesses a specific PauliTerm in the observable (const version). */
        auto operator[](std::size_t idx) const { return paulis_[idx]; }
        /** @brief Returns an iterator to the beginning of the PauliTerm vector. */
        decltype(auto) begin() { return paulis_.begin(); }
        /** @brief Returns a const iterator to the beginning of the PauliTerm vector. */
        decltype(auto) begin() const { return paulis_.begin(); }
        /** @brief Returns a const iterator to the beginning of the PauliTerm vector. */
        decltype(auto) cbegin() const { return paulis_.cbegin(); }
        /** @brief Returns an iterator to the end of the PauliTerm vector. */
        decltype(auto) end() { return paulis_.end(); }
        /** @brief Returns a const iterator to the end of the PauliTerm vector. */
        decltype(auto) end() const { return paulis_.end(); }
        /** @brief Returns a const iterator to the end of the PauliTerm vector. */
        decltype(auto) cend() const { return paulis_.cend(); }
        /** @brief Gets the number of Pauli terms in the observable. */
        std::size_t size() const { return paulis_.nb_terms(); }
        /* @brief Get the number of qubits of this Observable */
        std::size_t nb_qubits() const { return paulis_.nb_qubits(); }

        PauliTerm<T> copy_term(std::size_t idx) const {
                if (idx >= size()) {
                        throw std::invalid_argument("Index out of range");
                }
                // TODO: optimize
                auto nopt = (*this)[idx];
                return static_cast<PauliTerm<T>>(nopt);
        }

        /**
         * @brief Merges Pauli terms with identical Pauli strings.
         * @return The number of terms after the merge.
         *
         * This function iterates through all Pauli terms in the observable. If two or more
         * terms have the same Pauli string, their coefficients are added together, and they are
         * replaced by a single term. This is a crucial optimization for reducing the complexity of the simulation.
         */
        std::size_t merge() {
                merge_inplace_noalloc(paulis_);
                return paulis_.nb_terms();
        }

        /**
         * @brief Truncates the observable based on a given truncation strategy.
         * @tparam Truncator The type of the truncator object.
         * @param truncator The truncator object that defines the truncation logic.
         * @return The number of Pauli terms removed.
         * @see Truncator
         */
        template <typename Truncator>
        std::size_t truncate(Truncator&& truncator) {
                auto ret = truncator.truncate(paulis_);
                if (paulis_.nb_terms() == 0) {
                        const auto warn_env = std::getenv("WARN_EMPTY_TREE");
                        if (warn_env == nullptr || strcmp(warn_env, "0") != 0) {
                                std::cerr
                                        << "[ProPauli] Warning: truncation lead to empty tree. Disable this warning by setting `WARN_EMPTY_TREE=0`, if this is intended."
                                        << std::endl;
                        }
                }
                return ret;
        }

        friend bool operator==(Observable const& lhs, Observable const& rhs) {
                return lhs.size() == rhs.size() && lhs.paulis_ == rhs.paulis_;
        }

    private:
        // std::vector<PauliTerm<T>> paulis_;
        PauliTermContainer<T> paulis_;

        void check_invariant() const {
                if (paulis_.nb_terms() == 0) {
                        throw std::invalid_argument("Can't have empty observable (no terms)");
                }
                const auto nb_qubits = this->nb_qubits();
                if (nb_qubits == 0) {
                        throw std::invalid_argument("0 qubit observable not allowed.");
                }
                /*if (!std::all_of(paulis_.cbegin(), paulis_.cend(),
                                 [=](auto const& pt) { return pt.size() == nb_qubits; })) {
                        throw std::invalid_argument("Can't have observable with mismatching number of qubits.");
                }*/
        }

        void check_qubit(unsigned qubit) const {
                if (qubit >= nb_qubits()) {
                        throw std::invalid_argument("Qubit index out of range.");
                }
        }
};

template <typename T>
std::ostream& operator<<(std::ostream& os, Observable<T> const& obs) {
        bool first = true;
        for (std::size_t i = 0; i < obs.size(); ++i) {
                if (!first) {
                        os << " ";
                }
                os << obs.copy_term(i); // TODO: optimize

                first = false;
        }
        return os;
}

#endif

1	#ifndef PP_OBSERVABLE_HPP
2	#define PP_OBSERVABLE_HPP
3
4	#include "pauli.hpp"
5	#include "pauli_term.hpp"
6	#include "pauli_term_container.hpp"
7	#include "merge.hpp"
8
9	#include <algorithm>
10	#include <cstring>
11	#include <initializer_list>
12	#include <iostream>
13	#include <iterator>
14	#include <ostream>
15	#include <stdexcept>
16	#include <string_view>
17	#include <type_traits>
18	#include <unordered_map>
19	#include <vector>
20
21	/**
22	* @brief Represents a quantum observable as a linear combination of Pauli strings.
23	* @tparam T The numeric type for the coefficients (e.g., float, double).
24	*
25	* An `Observable` is a sum of `PauliTerm` objects, each consisting of a Pauli
26	* string and a coefficient. This class is the central data structure in the
27	* Pauli back-propagation simulation. Quantum gates are applied to this object,
28	* evolving it backward in the Heisenberg picture.
29	*/
30	template <typename T = coeff_t>
31	class Observable {
32	public:
33	/**
34	* @brief Constructs an observable from a single Pauli string.
35	* @param pauli_string A string representing the Pauli operators (e.g., "IXYZ").
36	* @param coeff The coefficient of this Pauli term.
37	*
38	* @snippet tests/snippets/observable.cpp observable_from_string
39	*/
40	Observable(std::string_view pauli_string,
41	typename std::enable_if_t<std::is_convertible_v<T, coeff_t>, T> coeff = T{ 1 })
42	: paulis_{ PauliTerm<T>(pauli_string, coeff) } {	14✔
43	check_invariant();	14✔
44	}	14✔
45
46	/**
47	* @brief Constructs an observable from a list of Pauli strings.
48	* @param pauli_string_list An initializer list of Pauli strings. Each will have a coefficient of 1.
49	*
50	* @snippet tests/snippets/observable.cpp observable_from_string_list
51	*/
52	Observable(std::initializer_list<std::string_view> pauli_string_list) : paulis_{ pauli_string_list } {	46✔
53	check_invariant();	46✔
54	}	46✔
55
56	/**
57	* @brief Constructs an observable from a list of PauliTerm objects.
58	* @param paulis_list An initializer list of `PauliTerm` objects.
59	*
60	* @snippet tests/snippets/observable.cpp observable_from_pauli_terms
61	*/
62	Observable(std::initializer_list<PauliTerm<T>> paulis_list) : paulis_{ paulis_list } { check_invariant(); }	16✔
63
64	/**
65	* @brief Constructs an observable from a range of PauliTerm objects.
66	* @tparam Iter An iterator type.
67	* @param begin An iterator to the beginning of the range.
68	* @param end An iterator to the end of the range.
69	*
70	* @snippet tests/snippets/observable.cpp observable_from_iterators
71	*/
72	template <PauliTermIterator Iter>
73	Observable(Iter&& begin, Iter&& end) : paulis_{ begin, end } {	4✔
74	check_invariant();	4✔
75	}	4✔
76
77	/**
78	* @brief Applies a single-qubit Pauli gate to the observable.
79	* @param g The Pauli gate to apply.
80	* @param qubit The index of the qubit to apply the gate to.
81	* @pre qubit index must be less than the number of qubits in the observable.
82	*/
83	void apply_pauli(Pauli_gates g, unsigned qubit) {	38✔
84	check_qubit(qubit);	38✔
85	for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {	95✔
86	paulis_[i].apply_pauli(g, qubit);	57✔
87	}	57✔
88	}	38✔
89
90	/**
91	* @brief Applies a single-qubit Clifford gate to the observable.
92	* @param g The Clifford gate to apply (e.g., Hadamard).
93	* @param qubit The index of the qubit to apply the gate to.
94	* @pre qubit index must be less than the number of qubits in the observable.
95	*/
96	void apply_clifford(Clifford_Gates_1Q g, unsigned qubit) {	98✔
97	check_qubit(qubit);	98✔
98	for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {	320✔
99	paulis_[i].apply_clifford(g, qubit);	222✔
100	}	222✔
101	}	98✔
102
103	/**
104	* @brief Applies a single-qubit unital noise channel to the observable.
105	* @param n The type of unital noise (e.g., Depolarizing, Dephasing).
106	* @param qubit The index of the qubit to apply the noise to.
107	* @param p The noise probability parameter.
108	* @pre qubit index must be less than the number of qubits in the observable.
109	*/
110	void apply_unital_noise(UnitalNoise n, unsigned qubit, T p) {	47✔
111	check_qubit(qubit);	47✔
112	for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {	137✔
113	paulis_[i].apply_unital_noise(n, qubit, p);	90✔
114	}	90✔
115	}	47✔
116
117	/**
118	* @brief Applies a CNOT (CX) gate to the observable.
119	* @param qubit_control The index of the control qubit.
120	* @param qubit_target The index of the target qubit.
121	* @pre qubits indexes must be less than the number of qubits in the observable.
122	* @pre control qubit != target qubit
123	*/
124	void apply_cx(unsigned qubit_control, unsigned qubit_target) {	118✔
125	check_qubit(qubit_control);	118✔
126	check_qubit(qubit_target);	118✔
127	if (qubit_control == qubit_target) {	118✔
128	throw std::invalid_argument("cx gate target must be != from control.");	1✔
129	}	1✔
130
131	for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {	267✔
132	paulis_[i].apply_cx(qubit_control, qubit_target);	150✔
133	}	150✔
134	}	117✔
135
136	/**
137	* @brief Applies a single-qubit Rz rotation gate to the observable.
138	* @param qubit The index of the qubit to apply the rotation to.
139	* @param theta The rotation angle in radians.
140	*
141	* @note This is a "splitting" operation. Applying an Rz gate to a Pauli term
142	* containing an X or Y operator on the target qubit will result in two
143	* output Pauli terms, potentially doubling the size of the observable.
144	*/
145	void apply_rz(unsigned qubit, T theta) {	103✔
146	check_qubit(qubit);	103✔
147
148	const auto nb_terms = paulis_.nb_terms();	103✔
149	// paulis_.reserve(nb_terms * 2);
150	for (std::size_t i = 0; i < nb_terms; ++i) {	549✔
151	auto p = paulis_[i];	446✔
152	if (!p.get_pauli(qubit).commutes_with(p_z)) {	446✔
153	auto new_path = paulis_.duplicate_pauliterm(i);	340✔
154	paulis_[i].apply_rz(qubit, theta, new_path);	340✔
155	}	340✔
156	}	446✔
157	}	103✔
158
159	/**
160	* @brief Applies an amplitude damping noise channel.
161	* @param qubit The index of the qubit to apply the channel to.
162	* @param pn The noise probability parameter.
163	*
164	* @note This can be a "splitting" operation. If the Pauli term has a Z operator
165	* on the target qubit, the term will be split into two. If it has X or Y, the
166	* coefficient is simply scaled. If it has I, there is no effect.
167	*/
168	void apply_amplitude_damping(unsigned qubit, T pn) {	45✔
169	check_qubit(qubit);	45✔
170	// paulis_.reserve(paulis_.size() * 2);
171	const auto nb_terms = paulis_.nb_terms();	45✔
172	for (std::size_t i = 0; i < nb_terms; ++i) {	123✔
173	auto p = paulis_[i];	78✔
174	if (p.get_pauli(qubit) == p_z) {	78✔
175	auto new_path = paulis_.duplicate_pauliterm(i); // invalidate p	58✔
176	paulis_[i].apply_amplitude_damping_z(qubit, pn, new_path);	58✔
177	} else if (p.get_pauli(qubit) == p_x \|\| p.get_pauli(qubit) == p_y) {	58✔
178	p.apply_amplitude_damping_xy(qubit, pn);	7✔
179	}	7✔
180	}	78✔
181	}	45✔
182
183	/**
184	* @brief Calculates the expectation value of the observable.
185	* @return The expectation value.
186	*
187	* The expectation value is calculated by summing the coefficients of all Pauli terms
188	* that commute with Z on all qubits (i.e., contain only I and Z operators).
189	*/
190	T expectation_value() const {	76✔
191	T ret = 0;	76✔
192	for (std::size_t i = 0; i < paulis_.nb_terms(); ++i) {	276✔
193	ret += paulis_[i].expectation_value();	200✔
194	}	200✔
195	return ret;	76✔
196	}	76✔
197
198	/** @brief Accesses a specific PauliTerm in the observable. */
199	auto operator[](std::size_t idx) { return paulis_[idx]; }	141✔
200	/** @brief Accesses a specific PauliTerm in the observable (const version). */
201	auto operator[](std::size_t idx) const { return paulis_[idx]; }	14✔
202	/** @brief Returns an iterator to the beginning of the PauliTerm vector. */
203	decltype(auto) begin() { return paulis_.begin(); }	14✔
204	/** @brief Returns a const iterator to the beginning of the PauliTerm vector. */
UNCOV 205	decltype(auto) begin() const { return paulis_.begin(); }	×
206	/** @brief Returns a const iterator to the beginning of the PauliTerm vector. */
207	decltype(auto) cbegin() const { return paulis_.cbegin(); }	11✔
208	/** @brief Returns an iterator to the end of the PauliTerm vector. */
209	decltype(auto) end() { return paulis_.end(); }	28✔
210	/** @brief Returns a const iterator to the end of the PauliTerm vector. */
UNCOV 211	decltype(auto) end() const { return paulis_.end(); }	×
212	/** @brief Returns a const iterator to the end of the PauliTerm vector. */
213	decltype(auto) cend() const { return paulis_.cend(); }	12✔
214	/** @brief Gets the number of Pauli terms in the observable. */
215	std::size_t size() const { return paulis_.nb_terms(); }	900✔
216	/* @brief Get the number of qubits of this Observable */
217	std::size_t nb_qubits() const { return paulis_.nb_qubits(); }	676✔
218
219	PauliTerm<T> copy_term(std::size_t idx) const {	13✔
220	if (idx >= size()) {	13!
NEW 221	throw std::invalid_argument("Index out of range");	×
NEW 222	}	×
223	// TODO: optimize
224	auto nopt = (*this)[idx];	13✔
225	return static_cast<PauliTerm<T>>(nopt);	13✔
226	}	13✔
227
228	/**
229	* @brief Merges Pauli terms with identical Pauli strings.
230	* @return The number of terms after the merge.
231	*
232	* This function iterates through all Pauli terms in the observable. If two or more
233	* terms have the same Pauli string, their coefficients are added together, and they are
234	* replaced by a single term. This is a crucial optimization for reducing the complexity of the simulation.
235	*/
236	std::size_t merge() {	97✔
237	merge_inplace_noalloc(paulis_);	97✔
238	return paulis_.nb_terms();	97✔
239	}	97✔
240
241	/**
242	* @brief Truncates the observable based on a given truncation strategy.
243	* @tparam Truncator The type of the truncator object.
244	* @param truncator The truncator object that defines the truncation logic.
245	* @return The number of Pauli terms removed.
246	* @see Truncator
247	*/
248	template <typename Truncator>
249	std::size_t truncate(Truncator&& truncator) {	81✔
250	auto ret = truncator.truncate(paulis_);	81✔
251	if (paulis_.nb_terms() == 0) {	81!
252	const auto warn_env = std::getenv("WARN_EMPTY_TREE");	2✔
253	if (warn_env == nullptr \|\| strcmp(warn_env, "0") != 0) {	2!
254	std::cerr	2✔
255	<< "[ProPauli] Warning: truncation lead to empty tree. Disable this warning by setting `WARN_EMPTY_TREE=0`, if this is intended."	2✔
256	<< std::endl;	2✔
257	}	2✔
258	}	2✔
259	return ret;	81✔
260	}	81✔
261
262	friend bool operator==(Observable const& lhs, Observable const& rhs) {	11✔
263	return lhs.size() == rhs.size() && lhs.paulis_ == rhs.paulis_;	11!
264	}	11✔
265
266	private:
267	// std::vector<PauliTerm<T>> paulis_;
268	PauliTermContainer<T> paulis_;
269
270	void check_invariant() const {	76✔
271	if (paulis_.nb_terms() == 0) {	76!
UNCOV 272	throw std::invalid_argument("Can't have empty observable (no terms)");	×
UNCOV 273	}	×
274	const auto nb_qubits = this->nb_qubits();	76✔
275	if (nb_qubits == 0) {	76✔
276	throw std::invalid_argument("0 qubit observable not allowed.");	1✔
277	}	1✔
278	/*if (!std::all_of(paulis_.cbegin(), paulis_.cend(),
279	[=](auto const& pt) { return pt.size() == nb_qubits; })) {
280	throw std::invalid_argument("Can't have observable with mismatching number of qubits.");
281	}*/
282	}	76✔
283
284	void check_qubit(unsigned qubit) const {	566✔
285	if (qubit >= nb_qubits()) {	566✔
286	throw std::invalid_argument("Qubit index out of range.");	7✔
287	}	7✔
288	}	566✔
289	};
290
291	template <typename T>
292	std::ostream& operator<<(std::ostream& os, Observable<T> const& obs) {	3✔
293	bool first = true;	3✔
294	for (std::size_t i = 0; i < obs.size(); ++i) {	8✔
295	if (!first) {	5✔
296	os << " ";	2✔
297	}	2✔
298	os << obs.copy_term(i); // TODO: optimize	5✔
299
300	first = false;	5✔
301	}	5✔
302	return os;	3✔
303	}	3✔
304
305	#endif

zeFresk / ProPauli / 17303326492

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous