Enum RegOpDiscriminants 

pub enum RegOpDiscriminants {
    Output,
    Input,
    CopyReg,
    CopyImm,
    NegReg,
    AbsReg,
    RecipReg,
    SqrtReg,
    SquareReg,
    FloorReg,
    CeilReg,
    RoundReg,
    SinReg,
    CosReg,
    TanReg,
    AsinReg,
    AcosReg,
    AtanReg,
    ExpReg,
    LnReg,
    NotReg,
    AddRegImm,
    MulRegImm,
    DivRegImm,
    DivImmReg,
    SubImmReg,
    SubRegImm,
    ModRegReg,
    ModRegImm,
    AtanRegImm,
    CompareRegImm,
    MinRegImm,
    MaxRegImm,
    AndRegImm,
    OrRegImm,
    ModImmReg,
    AtanImmReg,
    CompareImmReg,
    AddRegReg,
    MulRegReg,
    DivRegReg,
    SubRegReg,
    CompareRegReg,
    AtanRegReg,
    MinRegReg,
    MaxRegReg,
    AndRegReg,
    OrRegReg,
    Load,
    Store,
}

RegOp discriminant value

Variants

Output

Writes an output variable by index

Input

Read an input variable by index

CopyReg

Copies the given register

CopyImm

Copy an immediate to a register

NegReg

Negate the given register

AbsReg

Take the absolute value of the given register

RecipReg

Take the reciprocal of the given register (1.0 / value)

SqrtReg

Take the square root of the given register

SquareReg

Square the given register

FloorReg

Returns the largest integer less than or equal to self

CeilReg

Returns the smallest integer greater than or equal to self

RoundReg

Returns the nearest integer to self. If a value is half-way between two integers, round away from 0.0.

SinReg

Computes the sine of the given register (in radians)

CosReg

Computes the cosine of the given register (in radians)

TanReg

Computes the tangent of the given register (in radians)

AsinReg

Computes the arcsin of the given register (in radians)

AcosReg

Computes the arccos of the given register (in radians)

AtanReg

Computes the arctangent of the given register (in radians)

ExpReg

Computes the exponential function of the given register

LnReg

Computes the natural log of the given register

NotReg

Computes the logical negation of the given register

Equivalent to if arg == 0 { 1 } else { 0 }

AddRegImm

Add a register and an immediate

MulRegImm

Multiply a register and an immediate

DivRegImm

Divides a register and an immediate

DivImmReg

Divides an immediate by a register

SubImmReg

Subtract a register from an immediate

SubRegImm

Subtract an immediate from a register

ModRegReg

Take the module (least nonnegative remainder) of two registers

ModRegImm

Take the module (least nonnegative remainder) of a register and an immediate

AtanRegImm

atan2 of a position (y, x) specified as register, immediate

CompareRegImm

Compares a register with an immediate

MinRegImm

Compute the minimum of a register and an immediate

MaxRegImm

Compute the maximum of a register and an immediate

AndRegImm

Logical AND (short-circuiting)

This is equivalent to if lhs == 0 { lhs } else { imm }

OrRegImm

Logical OR (short-circuiting)

This is equivalent to if lhs != 0 { lhs } else { imm }

ModImmReg

Take the module (least nonnegative remainder) of an immediate and a register

AtanImmReg

atan2 of a position (y, x) specified as immediate, register

CompareImmReg

Compares an immediate with a register

AddRegReg

Add two registers

MulRegReg

Multiply two registers

DivRegReg

Divides two registers

SubRegReg

Subtract one register from another

CompareRegReg

Compares two registers

AtanRegReg

atan2 of a position (y, x) specified as register, register

MinRegReg

Take the minimum of two registers

MaxRegReg

Take the maximum of two registers

AndRegReg

Logical AND (short-circuiting)

This is equivalent to if lhs == 0 { lhs } else { rhs }

OrRegReg

Logical OR (short-circuiting)

This is equivalent to if lhs != 0 { lhs } else { rhs }

Load

Read from a memory slot to a register

Store

Write from a register to a memory slot

Implementations

impl RegOpDiscriminants

pub const fn from_repr(discriminant: usize) -> Option<RegOpDiscriminants>

Try to create Self from the raw representation

Trait Implementations

impl Clone for RegOpDiscriminants

fn clone(&self) -> RegOpDiscriminants

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RegOpDiscriminants

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

Formats the value using the given formatter.

impl EnumCount for RegOpDiscriminants

const COUNT: usize = 50usize

impl<'_enum> From<&'_enum RegOp> for RegOpDiscriminants

fn from(val: &'_enum RegOp) -> RegOpDiscriminants

Converts to this type from the input type.

impl<'_derivative_strum> From<&'_derivative_strum RegOpDiscriminants> for &'static str

fn from(x: &'_derivative_strum RegOpDiscriminants) -> &'static str

Converts to this type from the input type.

impl From<RegOp> for RegOpDiscriminants

fn from(val: RegOp) -> RegOpDiscriminants

Converts to this type from the input type.

impl From<RegOpDiscriminants> for &'static str

fn from(x: RegOpDiscriminants) -> &'static str

Converts to this type from the input type.

impl IntoEnumIterator for RegOpDiscriminants

type Iterator = RegOpDiscriminantsIter

fn iter() -> RegOpDiscriminantsIter

impl PartialEq for RegOpDiscriminants

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

impl Eq for RegOpDiscriminants

impl StructuralPartialEq for RegOpDiscriminants