Enum Expression

pub enum Expression {
    Address(MemoryReference),
    FunctionCall(FunctionCallExpression),
    Infix(InfixExpression),
    Number(Complex64),
    PiConstant,
    Prefix(PrefixExpression),
    Variable(String),
}

Variants

Address(MemoryReference)

FunctionCall(FunctionCallExpression)

Infix(InfixExpression)

Number(Complex64)

PiConstant

Prefix(PrefixExpression)

Variable(String)

Implementations

impl Expression

pub fn simplify(&mut self)

Simplify the expression as much as possible, in-place.

Example

use quil_rs::expression::Expression;
use std::str::FromStr;
use num_complex::Complex64;

let mut expression = Expression::from_str("cos(2 * pi) + 2").unwrap();
expression.simplify();

assert_eq!(expression, Expression::Number(Complex64::from(3.0)));

pub fn into_simplified(self) -> Self

Consume the expression, simplifying it as much as possible.

Example

use quil_rs::expression::Expression;
use std::str::FromStr;
use num_complex::Complex64;

let simplified = Expression::from_str("cos(2 * pi) + 2").unwrap().into_simplified();

assert_eq!(simplified, Expression::Number(Complex64::from(3.0)));

pub fn evaluate( &self, variables: &HashMap<String, Complex64>, memory_references: &HashMap<&str, Vec<f64>>, ) -> Result<Complex64, EvaluationError>

Evaluate an expression, expecting that it may be fully reduced to a single complex number. If it cannot be reduced to a complex number, return an error.

Example

use quil_rs::expression::Expression;
use std::str::FromStr;
use std::collections::HashMap;
use num_complex::Complex64;

let expression = Expression::from_str("%beta + theta[0]").unwrap();

let mut variables = HashMap::with_capacity(1);
variables.insert(String::from("beta"), Complex64::from(1.0));

let mut memory_references = HashMap::with_capacity(1);
memory_references.insert("theta", vec![2.0]);

let evaluated = expression.evaluate(&variables, &memory_references).unwrap();

assert_eq!(evaluated, Complex64::from(3.0))

pub fn substitute_variables( self, variable_values: &HashMap<String, Expression>, ) -> Self

Substitute an expression in the place of each matching variable. Consumes the expression and returns a new one.

Example

use quil_rs::expression::Expression;
use std::str::FromStr;
use std::collections::HashMap;
use num_complex::Complex64;

let expression = Expression::from_str("%x + %y").unwrap();

let mut variables = HashMap::with_capacity(1);
variables.insert(String::from("x"), Expression::Number(Complex64::from(1.0)));

let evaluated = expression.substitute_variables(&variables);

assert_eq!(evaluated, Expression::from_str("1.0 + %y").unwrap())

pub fn to_real(&self) -> Result<f64, EvaluationError>

If this is a number with imaginary part “equal to” zero (of small absolute value), return that number. Otherwise, error with an evaluation error of a descriptive type.

impl Expression

pub fn get_memory_references(&self) -> Vec<&MemoryReference>

Return, if any, the memory references contained within this Expression.

Trait Implementations

impl Add for Expression

type Output = Expression

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl AddAssign for Expression

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl BitXor for Expression

type Output = Expression

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> Self

Performs the ^ operation.

impl BitXorAssign for Expression

fn bitxor_assign(&mut self, other: Self)

Performs the ^= operation.

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Div for Expression

type Output = Expression

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self

Performs the / operation.

impl DivAssign for Expression

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl FromStr for Expression

type Err = ParseProgramError<Expression>

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Expression

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul for Expression

type Output = Expression

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl MulAssign for Expression

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl PartialEq for Expression

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Quil for Expression

fn write( &self, f: &mut impl Write, fall_back_to_debug: bool, ) -> Result<(), ToQuilError>

Write the Quil representation of the item to the given writer. If fall_back_to_debug is true, then it must not return an error.

fn to_quil(&self) -> Result<String, ToQuilError>

Return a string in valid Quil syntax or an error if the item cannot be represented with valid Quil.

fn to_quil_or_debug(&self) -> String

Return a string in valid Quil syntax if possible. Any individual component of this object which cannot be represented in Quil will be replaced with a Debug representation of that component.

impl Sub for Expression

type Output = Expression

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl SubAssign for Expression

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl Eq for Expression