expr-solver-lib 1.2.0

Mathematical expression evaluator with bytecode compilation and configurable numeric precision (f64 or 128-bit Decimal)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

//! Bytecode instruction definitions for the virtual machine.

use crate::ast::{BinOp, UnOp};
use crate::number::Number;
#[cfg(feature = "serialization")]
use serde::{Deserialize, Serialize};

/// Bytecode instructions for the stack-based virtual machine.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))]
pub enum Instr {
    Push(Number),
    Load(usize),  // Index into SymTable
    Store(usize), // Index into SymTable
    Neg,
    Add,
    Sub,
    Mul,
    Div,
    Pow,
    Fact,
    Call(usize, usize), // Index into SymTable and argument count
    Equal,
    NotEqual,
    Less,
    LessEqual,
    Greater,
    GreaterEqual,
    // Control flow
    Jmp(usize), // Unconditional jump to instruction index
    Jz(usize),  // Jump to instruction index if top of stack is zero (consumes value)
}

impl From<UnOp> for Instr {
    fn from(op: UnOp) -> Self {
        match op {
            UnOp::Neg => Instr::Neg,
            UnOp::Fact => Instr::Fact,
        }
    }
}

impl From<BinOp> for Instr {
    fn from(op: BinOp) -> Self {
        match op {
            BinOp::Add => Instr::Add,
            BinOp::Sub => Instr::Sub,
            BinOp::Mul => Instr::Mul,
            BinOp::Div => Instr::Div,
            BinOp::Pow => Instr::Pow,
            BinOp::Equal => Instr::Equal,
            BinOp::NotEqual => Instr::NotEqual,
            BinOp::Less => Instr::Less,
            BinOp::LessEqual => Instr::LessEqual,
            BinOp::Greater => Instr::Greater,
            BinOp::GreaterEqual => Instr::GreaterEqual,
        }
    }
}