Enum Param 

pub enum Param {
    Value(f64),
    Ref {
        index: usize,
        multiplier: f64,
        value: f64,
    },
}

A numeric parameter for rotation and phase gates.

A Param is either a concrete floating-point value (Param::Value) or a symbolic reference to an entry in a parameter vector (Param::Ref). The Ref variant enables deferred parameter binding for variational algorithms where the same circuit is evaluated at multiple parameter points.

Variants

Value(f64)

A concrete, pre-bound rotation angle (in radians).

Ref

A symbolic reference to a parameter vector entry.

The effective angle is value * multiplier. The value field stores the base value at binding time; multiplier can be adjusted (e.g., negated for inversion) without touching the underlying vector.

Fields

index: usize

Zero-based index into the process parameter vector.

multiplier: f64

Scaling factor applied to the parameter value.

value: f64

The concrete value of the parameter at binding time.

Implementations

impl Param

pub fn inverse(&self) -> Self

Returns the mathematical inverse of the parameter (i.e., the negation).

For Value(v) this returns Value(-v); for Ref this negates the multiplier field.

pub fn value(&self) -> f64

Returns the current floating-point value of the parameter.

For Param::Value this is a direct read. For Param::Ref the effective value is value * multiplier.

pub fn set_parameter(&self, parameters: &[f64]) -> Self

Binds a symbolic Param::Ref to a concrete value from parameters.

If self is already a Param::Value it is returned unchanged. Otherwise the result is Value(base_value * multiplier * parameters[index]).

pub fn add(&self, other: &Self) -> Option<Self>

Attempts to add two parameters together.

Returns Some(Value(a + b)) only when both operands are Param::Value. Any combination involving a Param::Ref returns None, because symbolic parameters cannot be merged algebraically at compile time.

pub fn is_near_zero(&self, epsilon: f64) -> bool

Returns true if the parameter’s effective rotation angle is within epsilon of zero.

For Param::Ref only the multiplier is inspected, since the actual parameter value is not known at compile time.

Trait Implementations

impl Clone for Param

fn clone(&self) -> Param

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Param

impl Debug for Param

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Param

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Param

fn eq(&self, other: &Param) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Param

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Param