Merge branch 'release/1.20'

Author: albeva

Cargo.toml

@@ -3,4 +3,4 @@ members = ["lib", "bin"]
 resolver = "2"
 
 [workspace.dependencies]
-rust_decimal = { version = "1.39", features = ["serde-bincode", "maths", "macros"] }
+rust_decimal = { version = "1.39", features = ["serde-bincode", "maths"] }

README.md

@@ -7,12 +7,24 @@ A mathematical expression evaluator library written in Rust with support for cus
 ## Features
 
 - **Mathematical expressions** - Arithmetic, comparisons, and built-in functions
-- **128-bit decimal precision** - No floating-point errors using `rust_decimal`
+- **Flexible numeric types** - Choose between fast f64 (default) or high-precision 128-bit Decimal
 - **Custom symbols** - Register your own constants and functions
 - **Rich error messages** - Syntax errors with source location highlighting
 - **Bytecode compilation** - Compile expressions to portable binary format
 - **Stack-based VM** - Efficient execution on a virtual machine
 
+## What's it For?
+
+Need to evaluate math but don't want to embed an entire scripting language? You're in the right place. 🎯
+
+**Perfect for:**
+- **Game engines** - Calculate damage formulas, level requirements, or item stats without hardcoding values
+- **Configuration files** - Let users write `price * 0.9` instead of forcing them to update every value manually
+- **Analytics dashboards** - Enable power users to define custom metrics: `(revenue - cost) / users`
+- **Form calculators** - Mortgage calculators, unit converters, or any user-facing math
+- **Educational tools** - Math tutoring apps, graphing calculators, or homework helpers
+- **Learning compilers** - Clean example of lexer, parser, and stack-based VM in ~2K lines of Rust
+
 ## How It Works
 
 Classic compiler pipeline with type-safe state transitions:
@@ -33,7 +45,35 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-expr-solver-lib = "1.1.1"
+expr-solver-lib = "1.2.0"
+```
+
+**Numeric Type Selection:**
+
+The library supports two numeric backends via feature flags (mutually exclusive):
+
+- **`f64-floats`** (default) - Standard f64 floating-point arithmetic. Faster and simpler, allows Inf and NaN results.
+- **`decimal-precision`** - 128-bit Decimal for high precision. No floating-point errors, checked arithmetic with overflow detection.
+
+To use high-precision Decimal:
+
+```toml
+[dependencies]
+expr-solver-lib = { version = "1.2.0", default-features = false, features = ["decimal-precision"] }
+```
+
+To enable bytecode serialization with f64:
+
+```toml
+[dependencies]
+expr-solver-lib = { version = "1.2.0", features = ["serialization"] }
+```
+
+To enable bytecode serialization with Decimal:
+
+```toml
+[dependencies]
+expr-solver-lib = { version = "1.2.0", default-features = false, features = ["decimal-precision", "serialization"] }
 ```
 
 ### As a binary
@@ -42,7 +82,7 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-expr-solver-bin = "1.1.1"
+expr-solver-bin = "1.2.0"
 ```
 
 ### Quick Evaluation
@@ -60,52 +100,83 @@ let result = eval("sqrt(16) + sin(pi/2)").unwrap();
 
 ### Custom Symbols
 
+```rust
+use expr_solver::{eval_with_table, SymTable, Number, ParseNumber};
+
+let mut table = SymTable::stdlib();
+table.add_const("x", Number::parse_number("10").unwrap()).unwrap();
+table.add_func("double", 1, false, |args| {
+    Ok(args[0] * Number::parse_number("2").unwrap())
+}).unwrap();
+
+let result = eval_with_table("double(x)", table).unwrap();
+assert_eq!(result.to_string(), "20");
+```
+
+Or with f64 (default):
+
 ```rust
 use expr_solver::{eval_with_table, SymTable};
-use rust_decimal_macros::dec;
 
 let mut table = SymTable::stdlib();
-table.add_const("x", dec!(10)).unwrap();
-table.add_func("double", 1, false, |args| Ok(args[0] * dec!(2))).unwrap();
+table.add_const("x", 10.0).unwrap();
+table.add_func("double", 1, false, |args| Ok(args[0] * 2.0)).unwrap();
 
 let result = eval_with_table("double(x)", table).unwrap();
-assert_eq!(result, dec!(20));
+assert_eq!(result, 20.0);
 ```
 
 ### Compile Once, Execute Many Times
 
 ```rust
-use expr_solver::{load, SymTable};
-use rust_decimal_macros::dec;
+use expr_solver::{Program, SymTable};
 
 // Compile expression
-let program = load("x * 2 + y").unwrap();
+let program = Program::new_from_source("x * 2 + y").unwrap();
 
 // Execute with different values
 let mut table = SymTable::new();
-table.add_const("x", dec!(10)).unwrap();
-table.add_const("y", dec!(5)).unwrap();
+table.add_const("x", 10.0).unwrap();
+table.add_const("y", 5.0).unwrap();
 
 let linked = program.link(table).unwrap();
-let result = linked.execute().unwrap(); // 25
+let result = linked.execute().unwrap(); // 25.0
+assert_eq!(result, 25.0);
 ```
 
-## Precision
+## Numeric Precision
+
+The library supports two numeric backends:
 
-Uses **128-bit `Decimal`** arithmetic for exact decimal calculations without floating-point errors.
+### f64 (Default)
+- Standard IEEE 754 double-precision floating-point
+- Fast and efficient for most use cases
+- Allows `Inf` and `NaN` results (e.g., `1/0` → `Inf`, `sqrt(-1)` → `NaN`)
+- Minimal error checking - only prevents panics
+
+### Decimal (Optional)
+- 128-bit fixed-point arithmetic via `rust_decimal`
+- Exact decimal representation (no 0.1 + 0.2 ≠ 0.3 issues)
+- Checked arithmetic with overflow/underflow detection
+- Domain validation (e.g., `sqrt(-1)` returns an error)
+- Ideal for financial calculations or when exact decimal precision is required
+
+**Choosing the right mode:**
+- Use **f64** (default) for general-purpose math, scientific computing, or when performance is critical
+- Use **Decimal** for financial applications, accounting, or when exact decimal representation is required
 
 ## Built-in Functions
 
 | Category       | Functions                                                                 |
 |----------------|---------------------------------------------------------------------------|
 | **Arithmetic** | `abs`, `sign`, `floor`, `ceil`, `round`, `trunc`, `fract`, `mod`, `clamp` |
-| **Trig**       | `sin`, `cos`, `tan`, `asin`*, `acos`*, `atan`*, `atan2`*                  |
-| **Hyperbolic** | `sinh`*, `cosh`*, `tanh`*                                                 |
-| **Exp/Log**    | `sqrt`, `cbrt`*, `pow`, `exp`, `exp2`*, `log`, `log2`*, `log10`, `hypot`* |
+| **Trig**       | `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`                      |
+| **Hyperbolic** | `sinh`, `cosh`, `tanh`                                                    |
+| **Exp/Log**    | `sqrt`, `cbrt`, `pow`, `exp`, `exp2`, `log`, `log2`, `log10`, `hypot`     |
 | **Variadic**   | `min`, `max`, `sum`, `avg` (1+ args)                                      |
 | **Special**    | `if(cond, then, else)`                                                    |
 
-\* *Uses f64 internally, may have minor precision differences*
+> **Note:** In `decimal-precision` mode, some operations (inverse trig, `pow`) use internal f64 conversion due to `rust_decimal` limitations, which may introduce small precision loss.
 
 ## Built-in Constants
 
@@ -153,8 +224,14 @@ expr-solver -t
 Run the test suite:
 
 ```bash
-# Run all tests
+# Run all tests with default f64 mode
 cargo test
+
+# Test with decimal-precision mode
+cargo test -p expr-solver-lib --no-default-features --features decimal-precision
+
+# Test binary with f64 mode
+cargo test -p expr-solver-bin
 ```
 
 ## License

bin/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "expr-solver-bin"
-version = "1.1.1"
+version = "1.2.0"
 edition = "2024"
 authors = ["Albert Varaksin <albeva@me.com>"]
 description = "Binary using the expr-solver-lib to solve math expressions from command line"
@@ -15,6 +15,5 @@ name = "expr-solver"
 path = "src/main.rs"
 
 [dependencies]
-expr-solver-lib = { version = "1.1.1", path = "../lib" }
+expr-solver-lib = { version = "1.2.0", path = "../lib", default-features = false, features = ["f64-floats", "serialization"] }
 clap = { version = "4.0", features = ["derive"] }
-rust_decimal = { workspace = true }

bin/src/main.rs

@@ -1,6 +1,5 @@
 use clap::{ArgAction, Parser};
-use expr_solver::{Program, SymTable, Symbol};
-use rust_decimal::prelude::*;
+use expr_solver::{Number, ParseNumber, Program, SymTable, Symbol};
 use std::path::PathBuf;
 
 /// A mathematical expression evaluator with compilation support
@@ -25,7 +24,7 @@ struct Args {
 
     /// Define constants (e.g., -D x=5.0)
     #[arg(short = 'D', long, value_parser = parse_key_val, action = ArgAction::Append)]
-    define: Vec<(String, f64)>,
+    define: Vec<(String, Number)>,
 
     /// List all available functions and constants
     #[arg(short = 't', long, conflicts_with_all=["expression", "expr", "input", "output", "assembly"])]
@@ -37,11 +36,14 @@ struct Args {
 }
 
 /// Parses a key=value pair for custom constant definitions.
-fn parse_key_val(s: &str) -> Result<(String, f64), Box<dyn std::error::Error + Send + Sync>> {
+fn parse_key_val(s: &str) -> Result<(String, Number), Box<dyn std::error::Error + Send + Sync>> {
     let pos = s
         .find('=')
         .ok_or_else(|| format!("invalid KEY=value: no `=` found in `{s}`"))?;
-    Ok((s[..pos].parse()?, s[pos + 1..].parse()?))
+    let key = s[..pos].parse()?;
+    let value = Number::parse_number(&s[pos + 1..])
+        .map_err(|e| format!("Failed to parse number: {}", e))?;
+    Ok((key, value))
 }
 
 fn main() {
@@ -73,7 +75,7 @@ fn run() -> Result<(), String> {
     };
 
     // Link the program with the symbol table
-    let program = program.link(table).map_err(|err| err.to_string())?;
+    let mut program = program.link(table).map_err(|err| err.to_string())?;
 
     // Act on the loaded program
     if args.assembly {
@@ -91,7 +93,7 @@ fn run() -> Result<(), String> {
 }
 
 /// Creates a symbol table with standard library and user-defined constants.
-fn create_symbol_table(defines: &[(String, f64)]) -> Result<SymTable, String> {
+fn create_symbol_table(defines: &[(String, Number)]) -> Result<SymTable, String> {
     let mut table = SymTable::stdlib();
 
     for (name, value) in defines {
@@ -104,10 +106,7 @@ fn create_symbol_table(defines: &[(String, f64)]) -> Result<SymTable, String> {
         }
 
         table
-            .add_const(
-                name.clone(),
-                Decimal::from_f64(*value).unwrap_or(Decimal::ZERO),
-            )
+            .add_const(name.clone(), *value, false)
             .map_err(|e| format!("Failed to add constant '{}': {}", name, e))?;
     }
 

lib/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "expr-solver-lib"
-version = "1.1.1"
+version = "1.2.0"
 edition = "2024"
 authors = ["Albert Varaksin <albeva@me.com>"]
-description = "A simple math expression solver library"
+description = "Mathematical expression evaluator with bytecode compilation and configurable numeric precision (f64 or 128-bit Decimal)"
 license = "MIT"
 readme = "../README.md"
 repository = "https://github.com/albeva/expr-solver"
@@ -13,12 +13,20 @@ categories = ["mathematics", "parser-implementations"]
 [lib]
 name = "expr_solver"
 
+[features]
+default = ["f64-floats"]
+f64-floats = []
+decimal-precision = ["dep:rust_decimal", "dep:rust_decimal_macros"]
+serialization = ["dep:serde", "dep:bincode"]
+
 [dependencies]
-indoc = "2.0.6"
-bincode = { version = "2.0.1", features = ["serde"] }
-serde = { version = "1.0", features = ["derive"] }
+bincode = { version = "2.0.1", features = ["serde"], optional = true }
+serde = { version = "1.0", features = ["derive"], optional = true }
 colored = "3.0.0"
 thiserror = "2.0.17"
 unicode-width = "0.2.2"
-rust_decimal_macros = { version = "1.39" }
-rust_decimal = { workspace = true }
+rust_decimal_macros = { version = "1.39", optional = true }
+rust_decimal = { workspace = true, optional = true }
+
+[dev-dependencies]
+indoc = "2.0.6"