Enum ZipTerm 

pub enum ZipTerm {
    Read(usize),
    Const(i64),
    Real(u64),
    Op(ZipOp, Box<ZipTerm>, Box<ZipTerm>),
    Select(Box<ZipTerm>, Box<ZipTerm>, Box<ZipTerm>),
    Abs(Box<ZipTerm>),
}

The term a zip loop computes from the elements it reads at the counter’s index: arithmetic, comparisons and selects over array elements and constants. A guarded accumulation (If P: Set s to s + E) is the select P ? E : 0; a call of one of the program’s pure functions is its body, inlined.

Variants

Read(usize)

The element of operand k (the k-th distinct array the loop reads, in reading order).

Const(i64)

Real(u64)

A Real constant, by its bits.

Op(ZipOp, Box<ZipTerm>, Box<ZipTerm>)

Select(Box<ZipTerm>, Box<ZipTerm>, Box<ZipTerm>)

cond ? then : else, cond a boolean.

Abs(Box<ZipTerm>)

abs(x).

Implementations

impl ZipTerm

pub fn real(v: f64) -> ZipTerm

The Real constant v.

pub fn ty(&self, reads: &[Ty]) -> Option<Ty>

The term’s type when operand k holds a reads[k]; None when an operator sees an operand it does not take, a select’s guard is not a boolean or its arms differ in type, or the term is a boolean select.

pub fn eval(&self, row: &[i64]) -> Option<i64>

The term’s value at one element, every operand an Int (row[k] the element of operand k), booleans as 0 and 1; None when an intermediate value leaves 64 bits or it has none.

pub fn eval_within(&self, row: &[i64], lo: i128, hi: i128) -> Option<i64>

Self::eval with every intermediate value held to lo..=hi (None when one leaves it).

pub fn value( &self, row: &[Scalar], ints: (i128, i128), reals: f64, ) -> Result<Scalar, Stop>

The term’s value at one element (row[k] the element of operand k) as the VM computes it, every Int held to ints and every Real finite and within ±reals. Only the arm a select takes is evaluated, as the VM’s If does (and a mux keeps).

Trait Implementations

impl Clone for ZipTerm

fn clone(&self) -> ZipTerm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ZipTerm

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

Formats the value using the given formatter.

impl Hash for ZipTerm

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 PartialEq for ZipTerm

fn eq(&self, other: &ZipTerm) -> 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 Eq for ZipTerm

impl StructuralPartialEq for ZipTerm