Enum ParameterValue 

pub enum ParameterValue {
    Param(Parameter),
    Fixed(f64),
}

A flexible input type for specifying parameters when constructing circuit operations.

This enum allows users to pass either raw numbers or symbolic Parameter objects to gate builders (like rx, ry, u).

Examples

use cqlib_core::circuit::circuit_param::ParameterValue;
use cqlib_core::circuit::Parameter;

// Create from float
let val1: ParameterValue = 1.5.into();

// Create from integer
let val2: ParameterValue = 42.into();

// Create from symbolic parameter
let param = Parameter::symbol("theta");
let val3: ParameterValue = param.into();

Variants

Param(Parameter)

A symbolic parameter (which may contain variables like “theta”).

Fixed(f64)

A fixed floating-point value.

Implementations

impl ParameterValue

pub fn scaled(&self, factor: f64) -> Self

Returns a scaled value, preserving the Fixed or Param variant.

Fixed values use floating-point multiplication. Symbolic values use expression multiplication and remain Param, even if the resulting expression is constant (including multiplication by zero). In affine expressions with unresolved symbols, coefficients are preserved without tolerance pruning. This method does not explicitly evaluate or canonicalize expressions. Unlike converting a Parameter with Into, it does not fold constants into Fixed values.

Fixed multiplication follows IEEE 754, including signed zero and overflow; validation of the resulting value remains the caller’s responsibility.

Panics

Panics if factor is not finite, for either variant.

Trait Implementations

impl Clone for ParameterValue

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParameterValue

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

Formats the value using the given formatter.

impl From<&Parameter> for ParameterValue

fn from(para: &Parameter) -> Self

Converts to this type from the input type.

impl From<&ParameterValue> for Parameter

fn from(para: &ParameterValue) -> Parameter

Converts to this type from the input type.

impl From<&str> for ParameterValue

fn from(para: &str) -> Self

Converts a string literal into a symbolic parameter.

use cqlib_core::circuit::circuit_param::ParameterValue;

let theta: ParameterValue = "theta".into();

impl From<Parameter> for ParameterValue

fn from(para: Parameter) -> Self

Converts a Parameter into a ParameterValue.

It attempts to eagerly evaluate the parameter if it represents a known constant (like Pi, E, or a simple number) to optimize storage.

impl From<ParameterValue> for Parameter

fn from(para: ParameterValue) -> Parameter

Converts to this type from the input type.

impl From<f64> for ParameterValue

fn from(v: f64) -> Self

Converts to this type from the input type.

impl From<i64> for ParameterValue

fn from(v: i64) -> Self

Converts to this type from the input type.

impl PartialEq for ParameterValue

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

Compares the construction form: two values are equal only when both are symbolic with structurally equal expressions, or both are fixed with the same value. A symbolic parameter and its evaluated fixed value compare unequal even when numerically identical.

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

Inequality operator !=.