uCalc API Version: 2.1.3-preview.2 Released: 6/16/2026

Warning

uCalc API Preview Release Notice:The documentation describes the intended behavior of the API. The current preview build contains incomplete features, unoptimized performance, and is subject to breaking changes.

ArgBool

Method

Product: 

Fast Math Parser

Class: 

Callback

Retrieves a boolean argument passed to a user-defined callback function.

Syntax

ArgBool(int)

Parameters

index
int
The 1-based index of the argument to retrieve.

Return

bool

The boolean value of the specified argument.

Remarks

The ArgBool method retrieves a boolean argument from within a callback function. It is the type-safe counterpart to the generic Arg method.

When a function is defined with a parameter explicitly typed as Bool (e.g., via DefineFunction), this method should be used within the callback to retrieve its value.

Type Safety and Conversion

Using ArgBool provides compile-time type safety and improves code clarity. It also leverages uCalc's internal type system, which will automatically attempt to convert compatible numeric types into booleans:

  • A non-zero numeric value is typically converted to true.
  • A zero value is converted to false.

This behavior makes expressions more flexible, as a user could pass 1 or 0 to a function expecting a boolean value.

Comparative Analysis

  • vs. Generic Arg(): The generic Arg() (or ArgDbl()) method returns a double. While a boolean could be retrieved and then cast, ArgBool() is more direct, efficient, and less error-prone. It signals clear intent in the code.

  • vs. Native C#/C++ Arguments: In a native function, arguments are passed directly on the stack or in registers. uCalc's callback model is different: arguments are stored in an internal structure within the uCalc.Callback object. Methods like ArgBool are the designated accessors for retrieving this data in a type-safe manner.

Examples

Return and other type-specific versions of Return
				
					using uCalcSoftware;

var uc = new uCalc();

static void BooleanAnd(uCalc.Callback cb) {
   cb.ReturnBool(cb.ArgBool(1) && cb.ArgBool(2));
}
static void AddInt16(uCalc.Callback cb) {
   //C# promots Int16 to int for arithmetic hence (Int16) to convert it back
   cb.ReturnInt16((Int16)(cb.ArgInt16(1) + cb.ArgInt16(2)));

}
static void AddInt32(uCalc.Callback cb) {
   cb.ReturnInt32(cb.ArgInt32(1) + cb.ArgInt32(2));
}
static void AddInt64(uCalc.Callback cb) {
   cb.ReturnInt64(cb.ArgInt64(1) + cb.ArgInt64(2));
}


uc.DefineFunction("BooleanAnd(x As Bool, y As Bool) As Bool", BooleanAnd);
uc.DefineFunction("AddInt16(x As Int16, y As Int16) As Int16", AddInt16);
uc.DefineFunction("AddInt32(x As Int32, y As Int32) As Int32", AddInt32);
uc.DefineFunction("AddInt64(x As Int64, y As Int64) As Int64", AddInt64);

Console.WriteLine(uc.EvalStr("BooleanAnd(true, false)"));
Console.WriteLine(uc.EvalStr("AddInt16(5.2, 4.1)"));
Console.WriteLine(uc.EvalStr("AddInt32(2, 3)"));
Console.WriteLine(uc.EvalStr("AddInt64(10, 20)"));
				
			
false
9
5
30
				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

void ucalc_call BooleanAnd(uCalcBase::Callback cb) {
   cb.ReturnBool(cb.ArgBool(1) && cb.ArgBool(2));
}
void ucalc_call AddInt16(uCalcBase::Callback cb) {
   
   cb.ReturnInt16(cb.ArgInt16(1) + cb.ArgInt16(2));
}
void ucalc_call AddInt32(uCalcBase::Callback cb) {
   cb.ReturnInt32(cb.ArgInt32(1) + cb.ArgInt32(2));
}
void ucalc_call AddInt64(uCalcBase::Callback cb) {
   cb.ReturnInt64(cb.ArgInt64(1) + cb.ArgInt64(2));
}
int main() {
   uCalc uc;

   uc.DefineFunction("BooleanAnd(x As Bool, y As Bool) As Bool", BooleanAnd);
   uc.DefineFunction("AddInt16(x As Int16, y As Int16) As Int16", AddInt16);
   uc.DefineFunction("AddInt32(x As Int32, y As Int32) As Int32", AddInt32);
   uc.DefineFunction("AddInt64(x As Int64, y As Int64) As Int64", AddInt64);

   cout << uc.EvalStr("BooleanAnd(true, false)") << endl;
   cout << uc.EvalStr("AddInt16(5.2, 4.1)") << endl;
   cout << uc.EvalStr("AddInt32(2, 3)") << endl;
   cout << uc.EvalStr("AddInt64(10, 20)") << endl;
}
				
			
false
9
5
30
				
					Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub BooleanAnd(ByVal cb As uCalc.Callback)
      cb.ReturnBool(cb.ArgBool(1) And cb.ArgBool(2))
   End Sub
   Public Sub AddInt16(ByVal cb As uCalc.Callback)
      
      cb.ReturnInt16(cb.ArgInt16(1) + cb.ArgInt16(2))
   End Sub
   Public Sub AddInt32(ByVal cb As uCalc.Callback)
      cb.ReturnInt32(cb.ArgInt32(1) + cb.ArgInt32(2))
   End Sub
   Public Sub AddInt64(ByVal cb As uCalc.Callback)
      cb.ReturnInt64(cb.ArgInt64(1) + cb.ArgInt64(2))
   End Sub
   Public Sub Main()
      Dim uc As New uCalc()
      
      uc.DefineFunction("BooleanAnd(x As Bool, y As Bool) As Bool", AddressOf BooleanAnd)
      uc.DefineFunction("AddInt16(x As Int16, y As Int16) As Int16", AddressOf AddInt16)
      uc.DefineFunction("AddInt32(x As Int32, y As Int32) As Int32", AddressOf AddInt32)
      uc.DefineFunction("AddInt64(x As Int64, y As Int64) As Int64", AddressOf AddInt64)
      
      Console.WriteLine(uc.EvalStr("BooleanAnd(true, false)"))
      Console.WriteLine(uc.EvalStr("AddInt16(5.2, 4.1)"))
      Console.WriteLine(uc.EvalStr("AddInt32(2, 3)"))
      Console.WriteLine(uc.EvalStr("AddInt64(10, 20)"))
   End Sub
End Module
				
			
false
9
5
30
Previous
Next