This method provides direct, high-performance access to the value of a variable that was explicitly defined with the Single data type.

🎯 Purpose and Use Cases

A single-precision float uses 32 bits of memory, offering a balance between range and precision that is suitable for many applications. It is particularly useful in memory-sensitive scenarios where the full 64-bit precision of a Double is unnecessary, such as:

• Storing large arrays of 3D coordinates in graphics or game development.
• Processing large batches of sensor or signal data.
• Any situation where memory usage can be halved by reducing floating-point precision without a significant impact on accuracy.

This is the getter counterpart to the setter method, which takes a float as an argument (e.g., .ValueSng(1.23)).

💡 Comparative Analysis

• vs. Native Type Casting (e.g., C# (float)obj): In native languages, you often cast a generic object or variant to the desired type, which can lead to runtime errors if the cast is invalid. uCalc's Item provides a type-safe accessor. Calling ValueSng() on an Item that is not of type Single will not perform an implicit conversion.

• vs. uc.EvalStr("MyVar"): Retrieving a value via EvalStr involves a multi-step process: the engine must look up the symbol name, evaluate it, and format the result as a string. In contrast, myItem.ValueSng() is a direct memory access operation, making it significantly faster and the preferred method for performance-critical code, especially within loops.

• vs. Direct Memory Binding: For ultimate performance, the DefineVariable method allows you to bind a uCalc variable directly to the memory address of a variable in your host application (e.g., via pointers in C++ or an unsafe context in C#). When a variable is bound this way, its value is always synchronized with the host, making explicit calls to ValueSng() unnecessary. ValueSng() remains the best practice for safe, programmatic access when direct memory binding is not used.