uCalc SDK Interactive Examples

Creating a variable in the default instance and retrieving its value.

Creating alternative names for Define commands

Creating an error handler that automatically defines variables on the fly by checking for an 'Undefined Identifier' error.

Creating isolated evaluation contexts.

Creating uCalc instances

Customizing token definitions (e.g., treating hyphens as part of a word).

Data type Reset

Defines a C-style line comment token (`//...`) and categorizes it as whitespace so it is ignored by the parser.

Defines a custom `sum_to` operator to calculate the sum of a numeric range, demonstrating a single-word operator.

Defines a recursive Factorial function using the IIf function for conditional logic.

Defines a simple `Add` function that is implemented by a native callback to perform addition.

Defines several application-level configuration constants for use in expressions.

Defines variables with explicit types, inferred types, and default types.

DefineVariable examples

DefineVariable; using pointers

Defining a callback function with a variable number of arguments

Defining a constant

Defining a new custom operator with a precedence level set relative to an existing operator.

Defining a simple variable and function.

Defining a token bracket pair

Defining another function using the same callback address of existing one

Defining one static and one dynamic route, then matching a URL against each.

Defining quoted text

Defining uCalc Strings and Expressions in the default uCalc object space

Demonstrates `ByExpr` to create a custom `Assert` function where the error message is only evaluated if the assertion fails, improving performance.

Demonstrates a practical callback that retrieves a 'host application setting', simulating I/O or access to native configuration.

Demonstrates automatic resource management in C++ using RAII and the Owned() method.

Demonstrates basic, one-line evaluations for numeric, string, and boolean expressions.

Demonstrates context isolation by retrieving the parent uCalc instance from a Matches object and evaluating an expression that only exists in that parent's context.

Demonstrates defining a function that is implemented by a native callback in the host application.

Demonstrates enabling multiple floating-point error types and observing the results.

Demonstrates getting a token's initial type and then changing it using the setter overload.

Demonstrates getting the last error message after a failed operation.

Demonstrates how `GlobalMaximum` invalidates a search if a rule matches too many times.

Demonstrates how a Transformer is created from a uCalc instance and used to apply Rules to text.

Demonstrates how uCalc's token-aware Transformer safely renames a variable without corrupting a string literal, a common failure point for Regex.

Demonstrates implicit parsing on assignment and implicit evaluation when writing to the console.

Demonstrates interoperability between `Transformer` and `String` objects, and chaining methods to create nested views.

Demonstrates introspection within a callback, retrieving the parameter count of the calling function.

Demonstrates the basic creation and immediate evaluation of an expression object.

Demonstrates the basic difference between getting all matches and filtering for only 'focusable' ones.

Demonstrates the basic functionality of clearing default tokens and adding a single new one.

Demonstrates the basic getter and setter functionality of the Description property.

Demonstrates the basic getter and setter syntax for a property

Demonstrates the basic LIFO (Last-In, First-Out) behavior of NextOverload with two simple rules.

Demonstrates the basic toggle functionality of the Active property.

Demonstrates the basic true/false state of the WasModified flag.

Demonstrates the core C# idioms: `using` for lifetime management, property syntax for setters/getters, and implicit string conversions.

Demonstrates the default `QuoteSensitive(true)` behavior, where a pattern match is ignored inside a string literal.

Demonstrates the difference in variable capture behavior when StatementSensitive is enabled versus disabled.

Demonstrates the pass/fail behavior of GlobalMinimum. If the rule doesn't find at least 3 'a's, the entire transform fails.

Demonstrates the power of token-awareness by safely renaming a variable while ignoring its name inside a string literal—a common failure point for character-based Regex.

Demonstrates the recommended practice of using a scoped block for automatic resource management, preventing memory leaks.

Demonstrates the Transformer's token-aware safety by correctly renaming a variable without corrupting a string literal or comment.

Demonstrates type punning by interpreting an unsigned byte (`Int8u`) result as a signed byte (`Int8`) to observe how values wrap around.

Demonstrates using `RewindOnChange` to create a recursive `AddUp` function within the expression transformer.

Demonstrates using `RewindOnChange(true)` to perform recursive-style transformations, such as creating a variadic `AddUp` function.

Demonstrates using the Text property with implicit conversions (shortcuts) to parse a simple config string.

Demonstrating in-place modification with uCalc.String.Replace

Demonstrating that a clone is independent and that modifying it does not affect the original.