uCalcSoftware 5.7.0-preview.1

uCalc: The High-Performance Math Expression Evaluator and Token-Aware Text Transformation Engine

Homepage | Documentation | Online interactive examples | What's New | Release Notes | License

uCalc is more than just a calculator—it is a complete, sandboxed language environment and text transformation engine that you can customize on the fly. Designed for C#, VB.NET, and C++ developers, across various platforms including Windows (x86, x64, ARM64), Linux (x64, ARM64), macOS (osx-64, osx-ARM64 Apple Silicon), uCalc allows you to parse and evaluate mathematical, logical, and string-based expressions provided as plain text at runtime.

Whether you need to safely evaluate user-defined formulas, build a custom Domain-Specific Language (DSL), or safely refactor code, uCalc provides a unified, high-performance engine that bridges the gap between simple eval() functions and heavyweight compiler tools like ANTLR.

Key Features & Capabilities:

• Token-Aware Text Transformation: Stop relying on brittle Regular Expressions. uCalc’s Transformer can understand structural context (like strings, nested brackets, and user-defined comment structures), allowing you to perform safe, structural find-and-replace operations without accidentally corrupting your data.

• Parse-Once, Evaluate-Many: Achieve near-native execution speeds. uCalc separates parsing from evaluation, allowing you to compile a string expression into a highly optimized object that can be evaluated repeatedly inside loops at maximum speed.

• Dynamic Runtime Syntax: Unlike static parser generators that require recompilation, uCalc allows you to invent new operators, custom keywords, and literal formats dynamically at runtime.

• Secure Sandboxing: Safely execute user-provided formulas without the severe code-injection risks associated with standard scripting eval() functions. Expressions can only access the variables and functions you explicitly define.

• Advanced Native Callbacks: Seamlessly bind expressions to your compiled C++, C# or VB.NET code. Go beyond basic value passing with Lazy Evaluation (ByExpr for building custom short-circuiting loops) and Metaprogramming (ByHandle for runtime argument introspection).

• Smart String Library: Chain fluent, token-aware string operations using a mutable, highly efficient string builder designed specifically for parsing and transformation tasks.

• Perfect for building: Spreadsheet calculation engines, dynamic report generators, robust static analysis/refactoring tools, game scripting environments, and custom DSLs.

Full documentation can be found at https://www.uCalc.com/documentation

Quick Start

using uCalcSoftware;

var uc = new uCalc();
// 1. Expression Parser: Evaluate a simple math or string expression
Console.WriteLine(uc.Eval("(100 - 50) / 2"));
Console.WriteLine(uc.EvalStr("UCase('hello') + ', world!'"));

// 2. Evaluate an expression faster in a loop
var myVar = uc.DefineVariable("x");
var expr = uc.Parse("x * 2");

for (var i = 1; i <= 5; i++) {
   myVar.Value(i);
   Console.WriteLine($"When x is {i}, result is: {expr.Evaluate()}");
}

// 3. Transformer: Perform a basic find-and-replace
using (var t = new uCalc.Transformer()) {
   t.FromTo("Hello", "Hi");
   Console.WriteLine($"Transformer Result: {t.Transform("Hello World")}");
}

// 4. String Library: Use a fluent, chainable operation
using (var s = new uCalc.String("The value is: important")) {
   s.After(":").ToUpper();
   Console.WriteLine($"String Library Result: {s}");
}

Links

• Homepage
• Documentation
• What's New
• Release Notes
• Online interactive examples
• License