C++ operators

namespace ops

class Allocate

#include <allocate.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

class Command

#include <cpp_command.hpp>

Subclassed by mindquantum::python::Command

Public Types

using gate_t = td::Operator

Public Functions

inline const auto &get_qubits() const

inline const auto &get_control_qubits() const

inline const gate_t &get_gate() const

class DaggerOperation

#include <dagger.hpp>

Public Functions

template<typename OpT>
inline explicit DaggerOperation(OpT &&op)

inline uint32_t num_targets() const

inline td::Operator adjoint() const

inline std::optional<td::UMatrix> matrix() const

inline bool operator==(const DaggerOperation &other) const

Public Static Functions

static inline constexpr std::string_view kind()

class Deallocate

#include <deallocate.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

class Entangle

#include <entangle.hpp>

Public Types

using non_const_num_targets = void

Public Functions

inline explicit Entangle(uint32_t num_targets)

inline td::Operator adjoint() const

inline uint32_t num_targets() const

inline bool operator==(const Entangle &other) const

Public Static Functions

static inline constexpr std::string_view kind()

class Invalid

#include <invalid.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

class Measure

#include <measure.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

class Ph

#include <ph.hpp>

Public Functions

inline explicit Ph(double angle)

inline Ph adjoint() const

inline constexpr bool is_symmetric() const

inline UMatrix2 const matrix() const

inline bool operator==(Ph const &other) const

inline const auto &angle() const

Public Static Functions

static inline constexpr std::string_view kind()

Public Static Attributes

static constexpr auto num_params = 1UL

class QFT

#include <qft.hpp>

Public Types

using non_const_num_targets = void

Public Functions

inline explicit QFT(uint32_t num_targets)

inline td::Operator adjoint() const

inline uint32_t num_targets() const

inline bool operator==(const QFT &other) const

Public Static Functions

static inline constexpr std::string_view kind()

class QubitOperator

#include <qubit_operator.hpp>

Public Types

using non_const_num_targets = void

using ComplexTerm = std::pair<std::vector<std::pair<uint32_t, char>>, std::complex<double>>

using ComplexTermsDict = std::map<std::vector<std::pair<uint32_t, char>>, std::complex<double>>

Public Functions

inline explicit QubitOperator(uint32_t num_targets, ComplexTermsDict terms)

inline td::Operator adjoint() const

inline uint32_t num_targets() const

inline bool operator==(const QubitOperator &other) const

inline const ComplexTermsDict &get_terms() const

inline QubitOperator Subtract(QubitOperator const &other) const

inline QubitOperator operator-(QubitOperator const &other) const

inline QubitOperator Multiply(QubitOperator const &other) const

inline QubitOperator operator*(QubitOperator const &other) const

inline bool is_close(const QubitOperator &other, double rel_tol = 1e-12, double abs_tol = 1e-12) const

inline bool is_identity(double abs_tol = 1e-12) const

Public Static Functions

static inline constexpr std::string_view kind()

class SqrtSwap

#include <sqrtswap.hpp>

Public Functions

inline uint32_t num_targets() const

inline td::Operator adjoint() const

Public Static Functions

static inline constexpr std::string_view kind()

static inline td::UMatrix4 const matrix()

class TimeEvolution

#include <time_evolution.hpp>

Public Types

using non_const_num_targets = void

Public Functions

inline TimeEvolution(uint32_t num_targets, QubitOperator hamiltonian, double time)

Constructor.

Overload required in some cases for metaprogramming with operators.

inline TimeEvolution(QubitOperator hamiltonian, double time)

Constructor.

inline MQ_NODISCARD TimeEvolution adjoint () const

inline MQ_NODISCARD uint32_t num_targets () const

inline bool operator==(const TimeEvolution &other) const

inline MQ_NODISCARD const QubitOperator & get_hamiltonian () const

inline MQ_NODISCARD auto get_time() const

inline MQ_NODISCARD auto param() const

Public Static Functions

static inline constexpr std::string_view kind()

namespace parametric

Typedefs

using subs_map_t = SymEngine::map_basic_basic

using basic_t = SymEngine::RCP<const SymEngine::Basic>

using double_list_t = std::vector<double>

using param_list_t = SymEngine::vec_basic

using gate_param_t = std::variant<std::monostate, double, double_list_t, param_list_t>

Functions

template<typename op_t> void register_gate_type() MQ_REQUIRES((concepts[[nodiscard]] gate_param_t get_param (const operator_t&optor) noexcept

Register a new gate class.

Note

If the gate is neither a parametric gate or a gate with an angle() method, this method is no-op.Get the parameters of an operation

Template Parameters

operator_t – Type of the gate to register

Parameters

optor – A quantum operation

template<typename op_t, typename ...args_t>
MQ_NODISCARD auto generate_subs(args_t&&... args)

Generate a substitution dictionary from a single double.

Pre

sizeof(args_t) == operator_t::num_params()

template<typename op_t>
MQ_NODISCARD auto generate_subs(const double_list_t &params)

Generate a substitution dictionary from an array of double.

See also

generate_subs_(const std::vector<T>& param) const;

template<typename op_t>
MQ_NODISCARD auto generate_subs(const param_list_t &params)

Generate a substitution dictionary from an array of expressions.

See also

generate_subs_(const std::vector<T>& param) const;

template<typename T>
auto to_symengine(T &&t)

template<typename derived_t, typename non_param_t, std::size_t mod_pi>
class AngleParametricBase : public mindquantum::ops::parametric::ParametricBase<derived_t, non_param_t, real::theta>

#include <angle_base.hpp>

Public Types

using operator_t = tweedledum::Operator

using parent_t = ParametricBase<derived_t, non_param_t, real::theta>

using base_t = AngleParametricBase

using self_t = AngleParametricBase<derived_t, non_param_t, mod_pi>

using non_param_type = non_param_t

using subs_map_t = SymEngine::map_basic_basic

Public Functions

inline MQ_NODISCARD bool operator== (const AngleParametricBase &other) const noexcept

Test whether another operation is the same as this instance.

inline MQ_NODISCARD auto adjoint() const noexcept

Get the adjoint of an AngleParametricBase gate instance.

inline MQ_NODISCARD non_param_type eval_full () const

Fully evaluate this parametric gate.

Attempt to fully evaluate this parametric gate (ie. evaluate all parameter numerically). The constructor of the non-parametric gate type is called by passing each of the numerically evaluated parameter in the order that is defined when passing the type as the template parameters to this base class.

Throws

SymEngine::SymEngineException – if the expression cannot be fully evaluated numerically

Returns

An instance of a non-parametric gate (non_param_type)

inline MQ_NODISCARD non_param_type eval_full (const subs_map_t &subs_map) const

Fully evaluate this parametric gate.

Attempt to fully evaluate this parametric gate (ie. evaluate all parameter numerically). The constructor of the non-parametric gate type is called by passing each of the numerically evaluated parameter in the order that is defined when passing the type as the template parameters to this base class.

This overload accepts a dictionary of substitutions to perform on the parameters.

Parameters

subs_map – Dictionary containing all the substitution to perform

Throws

SymEngine::SymEngineException – if the expression cannot be fully evaluated numerically

Returns

An instance of a non-parametric gate (non_param_type)

Public Static Functions

template<typename evaluated_param_t>
static inline MQ_NODISCARD auto to_param_type(const self_t&, evaluated_param_t &&evaluated_param)

Evaluation helper function.

template<typename evaluated_param_t>
static inline MQ_NODISCARD auto to_non_param_type(const self_t&, evaluated_param_t &&evaluated_param)

Evaluation helper function.

class P : public mindquantum::ops::parametric::AngleParametricBase<P, tweedledum::Op::P, 2>

#include <angle_gates.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

Public Static Attributes

static constexpr auto num_targets = traits::num_targets<tweedledum::Op::P>

template<typename derived_t, typename non_param_t, typename ...params_t>
class ParametricBase

#include <gate_base.hpp>

Public Types

using base_t = ParametricBase

using self_t = ParametricBase

using operator_t = tweedledum::Operator

using is_parametric = void

using non_param_type = non_param_t

using params_type = std::tuple<params_t...>

using param_array_t = std::array<basic_t, num_params>

using subs_map_t = SymEngine::map_basic_basic

Public Functions

template<typename ...Ts, typename T = self_t, typename = std::enable_if_t<T::has_const_num_targets && !traits::is_param_base<Ts...>::value>>
inline constexpr ParametricBase(Ts&&... args)

Constructor from a list of either C++ numeric types or symbolic expressions.

Note

This constructor expects exactly num_params arguments

Parameters

expr – List of SymEngine expressions

template<typename ...Ts, typename T = self_t, typename = std::enable_if_t<!T::has_const_num_targets>>
inline constexpr ParametricBase(uint32_t num_targets, Ts&&... args)

Constructor from a list of either C++ numeric types or symbolic expressions.

Note

This constructor expects exactly num_params arguments

Parameters

• num_targets – Number of target qubits

• expr – List of SymEngine expressions

template<typename T = self_t, typename = std::enable_if_t<T::has_const_num_targets>>
inline constexpr ParametricBase(param_array_t &&params)

Constructor from an array of parameters.

template<typename T = self_t, typename = std::enable_if_t<!T::has_const_num_targets>>
inline constexpr ParametricBase(uint32_t num_targets, param_array_t &&params)

Constructor from an array of parameters.

ParametricBase() = delete

ParametricBase(const ParametricBase&) = default

ParametricBase(ParametricBase&&) noexcept = default

ParametricBase &operator=(const ParametricBase&) = default

ParametricBase &operator=(ParametricBase&&) noexcept = default

template<typename T = non_param_type, typename = std::enable_if_t<!traits::has_const_num_targets_v<T>, uint32_t>> inline MQ_NODISCARD constexpr auto num_targets () const noexcept

inline MQ_NODISCARD bool operator== (const ParametricBase &other) const noexcept

Test whether another operation is the same as this instance.

inline MQ_NODISCARD bool operator!= (const ParametricBase &other) const noexcept

Test whether another operation is the same as this instance.

inline MQ_NODISCARD bool is_symmetric () const noexcept

True if this operation has no particular ordering of qubits.

inline MQ_NODISCARD constexpr const auto & param (std::size_t idx) const

Parameter getter method.

Parameters

idx – Index of parameter

Returns

Parameter at index idx

inline MQ_NODISCARD auto params() const noexcept

Get all the parameters in an array.

Returns

SymEngine::vec_basic (std::vector<...>) containing all parameters

inline MQ_NODISCARD derived_t eval (const subs_map_t &subs_map) const

Evaluate the parameters of this parametric gate using some substitutions.

This function does not attempt to fully evaluate this parametric gate (ie. evaluate all parameter numerically)

See also

non_param_type eval_full(const SymEngine::map_basic_basic& subs_map) const

Parameters

subs_map – Dictionary containing all the substitution to perform

Returns

An new instance of the parametric gate with evaluated parameters

inline MQ_NODISCARD auto eval_full() const

Fully evaluate this parametric gate.

Attempt to fully evaluate this parametric gate (ie. evaluate all parameter numerically). The constructor of the non-parametric gate type is called by passing each of the numerically evaluated parameter in the order that is defined when passing the type as the template parameters to this base class.

Throws

SymEngine::SymEngineException – if the expression cannot be fully evaluated numerically

Returns

An instance of a non-parametric gate (non_param_type)

inline MQ_NODISCARD auto eval_full(const subs_map_t &subs_map) const

Fully evaluate this parametric gate.

Attempt to fully evaluate this parametric gate (ie. evaluate all parameter numerically). The constructor of the non-parametric gate type is called by passing each of the numerically evaluated parameter in the order that is defined when passing the type as the template parameters to this base class.

This overload accepts a dictionary of substitutions to perform on the parameters.

Parameters

subs_map – Dictionary containing all the substitution to perform

Throws

SymEngine::SymEngineException – if the expression cannot be fully evaluated numerically

Returns

An instance of a non-parametric gate (non_param_type)

inline MQ_NODISCARD operator_t eval_smart () const

Evaluate the parameters of this parametric gate using some substitutions.

This function will attempt to fully evaluate this parametric gate if possible. This will happen only if, after substitutions, all the parameters have a numeric representation.

See also

non_param_type eval_full(const SymEngine::map_basic_basic& subs_map) const

Parameters

subs_map – Dictionary containing all the substitution to perform

Returns

An new instance of the parametric gate with evaluated parameters

inline MQ_NODISCARD operator_t eval_smart (const subs_map_t &subs_map) const

Evaluate the parameters of this parametric gate using some substitutions.

This function will attempt to fully evaluate this parametric gate if possible. This will happen only if, after substitutions, all the parameters have a numeric representation.

See also

non_param_type eval_full(const SymEngine::map_basic_basic& subs_map) const

Parameters

subs_map – Dictionary containing all the substitution to perform

Returns

An new instance of the parametric gate with evaluated parameters

Public Static Functions

static inline MQ_NODISCARD constexpr derived_t create_op ()

Create a default instance of derived_t type.

Overload only available if non_param_type has compile-time constant number of qubits

static inline MQ_NODISCARD constexpr derived_t create_op (uint32_t num_targets)

Create a default instance of derived_t type.

Overload only available if non_param_type does not have compile-time constant number of qubits

template<typename... funcs_t> static inline MQ_NODISCARD constexpr derived_t create_op (funcs_t &&... transforms)

Create an instance of derived_t type with some transformation on the parameters.

Overload only available if non_param_type has compile-time constant number of qubits

template<typename... funcs_t> static inline MQ_NODISCARD constexpr derived_t create_op (uint32_t num_targets, funcs_t &&... transforms)

Create an instance of derived_t type with some transformation on the parameters.

Overload only available if non_param_type does not have compile-time constant number of qubits

template<typename T = non_param_type, typename = std::enable_if_t<traits::has_const_num_targets_v<T>, uint32_t>> static inline MQ_NODISCARD constexpr auto num_targets_static () noexcept

static inline MQ_NODISCARD constexpr const auto & param_name (std::size_t idx)

Get the name of the parameter at some index.

Parameters

idx – Index of parameter

Public Static Attributes

static constexpr auto num_params = sizeof...(params_t)

static constexpr auto has_const_num_targets = traits::has_const_num_targets_v<non_param_type>

class Ph : public mindquantum::ops::parametric::AngleParametricBase<Ph, ops::Ph, 2>

#include <angle_gates.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

Public Static Attributes

static constexpr auto num_targets = traits::num_targets<ops::Ph>

class Rx : public mindquantum::ops::parametric::AngleParametricBase<Rx, tweedledum::Op::Rx, 4>

#include <angle_gates.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

Public Static Attributes

static constexpr auto num_targets = traits::num_targets<tweedledum::Op::Rx>

class Rxx : public mindquantum::ops::parametric::AngleParametricBase<Rxx, tweedledum::Op::Rxx, 4>

#include <angle_gates.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

Public Static Attributes

static constexpr auto num_targets = traits::num_targets<tweedledum::Op::Rxx>

class Ry : public mindquantum::ops::parametric::AngleParametricBase<Ry, tweedledum::Op::Ry, 4>

#include <angle_gates.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

Public Static Attributes

static constexpr auto num_targets = traits::num_targets<tweedledum::Op::Ry>

class Ryy : public mindquantum::ops::parametric::AngleParametricBase<Ryy, tweedledum::Op::Ryy, 4>

#include <angle_gates.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

Public Static Attributes

static constexpr auto num_targets = traits::num_targets<tweedledum::Op::Ryy>

class Rz : public mindquantum::ops::parametric::AngleParametricBase<Rz, tweedledum::Op::Rz, 4>

#include <angle_gates.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

Public Static Attributes

static constexpr auto num_targets = traits::num_targets<tweedledum::Op::Rz>

class Rzz : public mindquantum::ops::parametric::AngleParametricBase<Rzz, tweedledum::Op::Rzz, 4>

#include <angle_gates.hpp>

Public Static Functions

static inline constexpr std::string_view kind()

Public Static Attributes

static constexpr auto num_targets = traits::num_targets<tweedledum::Op::Rzz>

class TimeEvolution : public mindquantum::ops::parametric::ParametricBase<TimeEvolution, ops::TimeEvolution, real::alpha>

#include <time_evolution.hpp>

Public Types

using operator_t = tweedledum::Operator

using parent_t = ParametricBase<TimeEvolution, ops::TimeEvolution, real::alpha>

using self_t = TimeEvolution

using non_const_num_targets = void

using non_param_type = non_param_t

using subs_map_t = SymEngine::map_basic_basic

Public Functions

template<typename param_t>
inline TimeEvolution(uint32_t num_targets, QubitOperator hamiltonian, param_t &&param)

Constructor.

Overload required in some cases for metaprogramming with operators.

template<typename param_t>
inline TimeEvolution(QubitOperator hamiltonian, param_t &&param)

Constructor.

inline MQ_NODISCARD auto adjoint() const noexcept

Get the adjoint of an TimeEvolution gate instance.

inline bool operator==(const self_t &other) const

inline MQ_NODISCARD const QubitOperator & get_hamiltonian () const

inline MQ_NODISCARD const auto & get_time () const

Public Static Functions

static inline constexpr std::string_view kind()

template<typename evaluated_param_t>
static inline MQ_NODISCARD auto to_param_type(const self_t &self, evaluated_param_t &&evaluated_param)

template<typename evaluated_param_t>
static inline MQ_NODISCARD auto to_non_param_type(const self_t &self, evaluated_param_t &&evaluated_param)

namespace complex

struct alpha

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "alpha"

struct beta

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "beta"

struct chi

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "chi"

struct delta

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "delta"

struct epsilon

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "epsilon"

struct eta

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "eta"

struct gamma

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "gamma"

struct iota

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "iota"

struct kappa

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "kappa"

struct lambda

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "lambda"

struct mu

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "mu"

struct nu

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "nu"

struct omega

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "omega"

struct omicron

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "omicron"

struct phi

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "phi"

struct pi

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "pi"

struct rho

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "rho"

struct sigma

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "sigma"

struct tau

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "tau"

struct theta

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "theta"

struct upsilon

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "upsilon"

struct xi

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "xi"

struct zeta

#include <param_names.hpp>

Public Types

using param_type = details::complex_tag_t

Public Static Attributes

static constexpr std::string_view name = "zeta"

namespace details

Functions

template<typename op_t, typename T>
MQ_NODISCARD auto generate_subs(const std::vector<T> &params)

Generate a substitution dictionary from an array of elements.

Pre

size(param) == op_t::num_params()

template<typename op_t, std::size_t... indices, typename ...args_t>
MQ_NODISCARD auto create_subs_from_params(std::index_sequence<indices...>, args_t&&... args)

void register_gate(std::string_view kind, double_func_t angle_func)

void register_gate(std::string_view kind, vec_double_func_t vec_double_func)

void register_gate(std::string_view kind, params_func_t params_func)

struct complex_tag_t

#include <param_names.hpp>

Defines a complex parameter.

Public Types

using type = std::complex<double>

Public Static Functions

static inline auto eval(const basic_t &expr)

struct real_tag_t

#include <param_names.hpp>

Defines a real parameter.

Public Types

using type = double

Public Static Functions

static inline auto eval(const basic_t &expr)

namespace real

struct alpha

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "alpha"

struct beta

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "beta"

struct chi

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "chi"

struct delta

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "delta"

struct epsilon

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "epsilon"

struct eta

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "eta"

struct gamma

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "gamma"

struct iota

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "iota"

struct kappa

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "kappa"

struct lambda

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "lambda"

struct mu

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "mu"

struct nu

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "nu"

struct omega

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "omega"

struct omicron

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "omicron"

struct phi

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "phi"

struct pi

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "pi"

struct rho

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "rho"

struct sigma

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "sigma"

struct tau

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "tau"

struct theta

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "theta"

struct upsilon

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "upsilon"

struct xi

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "xi"

struct zeta

#include <param_names.hpp>

Public Types

using param_type = details::real_tag_t

Public Static Attributes

static constexpr std::string_view name = "zeta"