Enum OpCode 

pub enum OpCode {
    LoadConst(u16),
    LoadBand(u16),
    LoadCacheSlot(u16),
    StoreCacheSlot(u16),
    Add,
    Sub,
    Mul,
    Div,
    Pow,
    Neg,
    Abs,
    Sqrt,
    Log,
    Ln,
    Exp,
    Sin,
    Cos,
    Tan,
    Floor,
    Ceil,
    Round,
    Min,
    Max,
    Clamp,
    Gt,
    Lt,
    Gte,
    Lte,
    Eq,
    Ne,
    And,
    Or,
    Cond,
}

A single instruction in the band-math VM.

The VM is a pure stack machine: operands are pushed onto the stack and operations pop their arguments and push one result.

Variants

LoadConst(u16)

Push constants[idx] onto the stack.

LoadBand(u16)

Push bands[idx - 1][pixel_idx] (1-based band index).

LoadCacheSlot(u16)

Push the pre-computed CSE cache value at cache[idx].

StoreCacheSlot(u16)

Pop the top of the stack and store it in cache[idx].

Add

Floating-point addition.

Sub

Floating-point subtraction.

Mul

Floating-point multiplication.

Div

Floating-point division (returns NaN on divide-by-zero).

Pow

Power: lhs.powf(rhs).

Neg

Arithmetic negation.

Abs

Absolute value.

Sqrt

Square root.

Log

Log base 10 (log10).

Ln

Natural logarithm (ln).

Exp

Exponential (e^x).

Sin

Sine.

Cos

Cosine.

Tan

Tangent.

Floor

Floor (round towards negative infinity).

Ceil

Ceiling (round towards positive infinity).

Round

Round to nearest integer.

Min

Pop b, pop a, push min(a, b).

Max

Pop b, pop a, push max(a, b).

Clamp

Pop max_v, pop min_v, pop val; push val.clamp(min_v, max_v).

Gt

lhs > rhs → 1.0 else 0.0

Lt

lhs < rhs → 1.0 else 0.0

Gte

lhs >= rhs → 1.0 else 0.0

Lte

lhs <= rhs → 1.0 else 0.0

Eq

|lhs - rhs| < ε → 1.0 else 0.0

Ne

|lhs - rhs| >= ε → 1.0 else 0.0

And

Both operands non-zero → 1.0 else 0.0

Or

At least one operand non-zero → 1.0 else 0.0

Cond

Pop else_val (top), pop then_val, pop cond. Push then_val if cond != 0.0, else else_val.

Trait Implementations

impl Clone for OpCode

fn clone(&self) -> OpCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OpCode

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

Formats the value using the given formatter.

impl PartialEq for OpCode

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