💾 Working with Variables

Variables are named placeholders that store values for use in your expressions. They are fundamental to creating dynamic and reusable logic in uCalc. Unlike constants, the value of a variable can be changed at any time.

1. Defining and Using Variables

The easiest way to create a variable is with the DefineVariable method. You can define its name, data type, and initial value in a single, readable string.

csharp
// Define a variable 'rate' with an initial value of 0.05
uc.DefineVariable("rate = 0.05");

// Use the variable in an expression
Console.WriteLine(uc.EvalStr("100 * rate")); // Output: 5


Type Inference and Explicit Typing

uCalc automatically infers the data type from the initial value:

• x = 10 becomes a numeric type (usually Double).
• name = 'Alice' becomes a String.

You can also explicitly declare a type using the As keyword, which is useful for ensuring type safety or optimizing memory usage.

csharp
// Explicitly define an integer variable
uc.DefineVariable("counter As Int = 0");


2. Interacting from Host Code

For high-performance applications, especially those involving loops, repeatedly calling EvalStr to set a variable's value is inefficient because it requires parsing a string every time. The recommended approach is to get a handle to the variable's Item object and modify its value directly from your host code (C#, C++, etc.).

csharp
// Get a handle to the variable when you define it
var myVar = uc.DefineVariable("x");

// Parse an expression that uses the variable ONCE
var expr = uc.Parse("x * 2");

// In a loop, update the value directly and evaluate the pre-parsed expression
for ( i = 1; i <= 3; i++) {
myVar.Value(i); // This is a fast, direct value update
Console.WriteLine($"Result: {expr.Evaluate()}"); // This is a fast evaluation
}


This two-step pattern (parse once, update and evaluate many times) is the key to achieving high performance with uCalc.

💡 Why uCalc? (Comparative Analysis)

• vs. C#/C++: Variables in compiled languages are defined at compile-time. uCalc's variables are created at runtime, allowing you to build dynamic systems where variables can be defined based on user input, configuration files, or other runtime conditions.

• vs. Dynamic Languages (Python, JavaScript): While also dynamic, uCalc provides a sandboxed environment with a clear distinction between the host application and the script engine. The programmatic interaction via Item.Value() offers a highly optimized bridge between these two worlds.

• Host Memory Binding: For ultimate performance, uCalc allows you to bind a variable directly to a memory address in your host application using an optional parameter in DefineVariable. This creates a zero-copy link, which is a powerful feature for tight integrations.