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.

DefaultDataType = [DataType]

Property

Product: 

Fast Math Parser

Class: 

uCalcBase

Gets or sets the default data type used for implicit typing during definitions and evaluation.

Remarks

The DefaultDataType property determines the fallback data type used by the uCalc engine when a type is not explicitly specified or cannot be inferred from context.

Default Behavior

At startup, the default data type is Double (64-bit floating point). This means that generic variable definitions and math operations default to double-precision floating-point arithmetic.

Getter / Setter Pattern

  • Get: Call this method without arguments to retrieve the current default type object.
  • Set: Pass a DataType object, a BuiltInType enum member, or a type name string to set a new default. The method returns the newly set type.

Impact on Operations

Changing the default data type affects the following areas:

  1. Implicit Variable Definition: Variables defined without an As Type clause or an initialization expression will assume this type.
  2. Function Signatures: Function parameters and return values defined without explicit types will assume this type.
  3. Evaluation Output:
    • Eval: Returns double. If the default type is set to something else (e.g., Integer), the result is converted to that type internally, then cast back to double for the return value.
    • EvalStr: Converts the result to the default type before formatting it as a string.

Shortcuts

While the method signature expects a DataType object, uCalc provides internal overloads allowing you to pass:

  • Enum: uc.DefaultDataType(BuiltInType::Integer_32)
  • String: uc.DefaultDataType("Int32")

These are equivalent to calling uc.DefaultDataType(uc.DataTypeOf("Int32")).

Comparative Analysis

In statically typed languages like C# (var) or C++ (auto), types are inferred from the initialization value (e.g., var x = 5 implies int). If no initialization exists, code usually fails to compile.

uCalc is more dynamic; if a user defines Variable: x without initialization, uCalc must choose a type to allocate memory. DefaultDataType controls this choice. This is similar to VB's Option Strict Off where untyped variables might default to Object, except uCalc defaults to Double (or your custom setting) for mathematical efficiency.

Examples

Setting/retrieving default data type
				
					using uCalcSoftware;

var uc = new uCalc();
// Check default data type
Console.WriteLine(uc.DefaultDataType.Name);

// This examples shows setting the default data type in 3
// different ways: by BuiltInType enum, DataType ojbect,
// or data type by name (string)

// Change default default data type
uc.DefaultDataType = uc.DataTypeOf(BuiltInType.Integer_16);
Console.WriteLine(uc.DefaultDataType.Name);

// Test new default (returns integers instead of double)

uc.DefineFunction("ff(x, y) = (x + y)/3");
// same as ff(x As int16, y As int16) As int16 = ...

uc.DefineFunction("gg(x) = x*100");
// same as gg(x As int16) As int16 = ...

Console.WriteLine(uc.Eval("ff(4, 12)"));
Console.WriteLine(uc.Eval("gg(6.1)"));

uc.SetDefaultDataType("Single");
Console.WriteLine(uc.DefaultDataType.Name);

// Change back to original default (double)
uc.SetDefaultDataType(BuiltInType.Float_Double);

// Verify that default is now double
Console.WriteLine(uc.DefaultDataType.Name);
				
			
double
int16
5
600
single
double
				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

int main() {
   uCalc uc;
   // Check default data type
   cout << uc.DefaultDataType().Name() << endl;

   // This examples shows setting the default data type in 3
   // different ways: by BuiltInType enum, DataType ojbect,
   // or data type by name (string)

   // Change default default data type
   uc.DefaultDataType(uc.DataTypeOf(BuiltInType::Integer_16));
   cout << uc.DefaultDataType().Name() << endl;

   // Test new default (returns integers instead of double)

   uc.DefineFunction("ff(x, y) = (x + y)/3");
   // same as ff(x As int16, y As int16) As int16 = ...

   uc.DefineFunction("gg(x) = x*100");
   // same as gg(x As int16) As int16 = ...

   cout << uc.Eval("ff(4, 12)") << endl;
   cout << uc.Eval("gg(6.1)") << endl;

   uc.SetDefaultDataType("Single");
   cout << uc.DefaultDataType().Name() << endl;

   // Change back to original default (double)
   uc.SetDefaultDataType(BuiltInType::Float_Double);

   // Verify that default is now double
   cout << uc.DefaultDataType().Name() << endl;
}
				
			
double
int16
5
600
single
double
				
					Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Check default data type
      Console.WriteLine(uc.DefaultDataType.Name)
      
      '// This examples shows setting the default data type in 3
      '// different ways: by BuiltInType enum, DataType ojbect,
      '// or data type by name (string)
      
      '// Change default default data type
      uc.DefaultDataType = uc.DataTypeOf(BuiltInType.Integer_16)
      Console.WriteLine(uc.DefaultDataType.Name)
      
      '// Test new default (returns integers instead of double)
      
      uc.DefineFunction("ff(x, y) = (x + y)/3")
      '// same as ff(x As int16, y As int16) As int16 = ...
      
      uc.DefineFunction("gg(x) = x*100")
      '// same as gg(x As int16) As int16 = ...
      
      Console.WriteLine(uc.Eval("ff(4, 12)"))
      Console.WriteLine(uc.Eval("gg(6.1)"))
      
      uc.SetDefaultDataType("Single")
      Console.WriteLine(uc.DefaultDataType.Name)
      
      '// Change back to original default (double)
      uc.SetDefaultDataType(BuiltInType.Float_Double)
      
      '// Verify that default is now double
      Console.WriteLine(uc.DefaultDataType.Name)
   End Sub
End Module
				
			
double
int16
5
600
single
double
Setting/retrieving default data type
				
					using uCalcSoftware;

var uc = new uCalc();
// Check default data type
Console.WriteLine(uc.DefaultDataType.Name);

// This examples shows setting the default data type in 3
// different ways: by BuiltInType enum, DataType ojbect,
// or data type by name (string)

// Change default default data type
uc.DefaultDataType = uc.DataTypeOf(BuiltInType.Integer_16);
Console.WriteLine(uc.DefaultDataType.Name);

// Test new default (returns integers instead of double)

uc.DefineFunction("ff(x, y) = (x + y)/3");
// same as ff(x As int16, y As int16) As int16 = ...

uc.DefineFunction("gg(x) = x*100");
// same as gg(x As int16) As int16 = ...

Console.WriteLine(uc.Eval("ff(4, 12)"));
Console.WriteLine(uc.Eval("gg(6.1)"));

uc.SetDefaultDataType("Single");
Console.WriteLine(uc.DefaultDataType.Name);

// Change back to original default (double)
uc.SetDefaultDataType(BuiltInType.Float_Double);

// Verify that default is now double
Console.WriteLine(uc.DefaultDataType.Name);
				
			
double
int16
5
600
single
double
				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

int main() {
   uCalc uc;
   // Check default data type
   cout << uc.DefaultDataType().Name() << endl;

   // This examples shows setting the default data type in 3
   // different ways: by BuiltInType enum, DataType ojbect,
   // or data type by name (string)

   // Change default default data type
   uc.DefaultDataType(uc.DataTypeOf(BuiltInType::Integer_16));
   cout << uc.DefaultDataType().Name() << endl;

   // Test new default (returns integers instead of double)

   uc.DefineFunction("ff(x, y) = (x + y)/3");
   // same as ff(x As int16, y As int16) As int16 = ...

   uc.DefineFunction("gg(x) = x*100");
   // same as gg(x As int16) As int16 = ...

   cout << uc.Eval("ff(4, 12)") << endl;
   cout << uc.Eval("gg(6.1)") << endl;

   uc.SetDefaultDataType("Single");
   cout << uc.DefaultDataType().Name() << endl;

   // Change back to original default (double)
   uc.SetDefaultDataType(BuiltInType::Float_Double);

   // Verify that default is now double
   cout << uc.DefaultDataType().Name() << endl;
}
				
			
double
int16
5
600
single
double
				
					Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Check default data type
      Console.WriteLine(uc.DefaultDataType.Name)
      
      '// This examples shows setting the default data type in 3
      '// different ways: by BuiltInType enum, DataType ojbect,
      '// or data type by name (string)
      
      '// Change default default data type
      uc.DefaultDataType = uc.DataTypeOf(BuiltInType.Integer_16)
      Console.WriteLine(uc.DefaultDataType.Name)
      
      '// Test new default (returns integers instead of double)
      
      uc.DefineFunction("ff(x, y) = (x + y)/3")
      '// same as ff(x As int16, y As int16) As int16 = ...
      
      uc.DefineFunction("gg(x) = x*100")
      '// same as gg(x As int16) As int16 = ...
      
      Console.WriteLine(uc.Eval("ff(4, 12)"))
      Console.WriteLine(uc.Eval("gg(6.1)"))
      
      uc.SetDefaultDataType("Single")
      Console.WriteLine(uc.DefaultDataType.Name)
      
      '// Change back to original default (double)
      uc.SetDefaultDataType(BuiltInType.Float_Double)
      
      '// Verify that default is now double
      Console.WriteLine(uc.DefaultDataType.Name)
   End Sub
End Module
				
			
double
int16
5
600
single
double
Quick Start: Getting and Setting the Default Type
				
					using uCalcSoftware;

var uc = new uCalc();
// 1. Check startup default (usually Double)
Console.WriteLine($"Start: {uc.DefaultDataType.Name}");

// 2. Change default to 32-bit Integer
uc.SetDefaultDataType(BuiltInType.Integer_32);
Console.WriteLine($"New: {uc.DefaultDataType.Name}");

// 3. Reset to Double using string shortcut
uc.SetDefaultDataType("Double");
Console.WriteLine($"Reset: {uc.DefaultDataType.Name}");

				
			
Start: double
New: int
Reset: double
				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

int main() {
   uCalc uc;
   // 1. Check startup default (usually Double)
   cout << "Start: " << uc.DefaultDataType().Name() << endl;

   // 2. Change default to 32-bit Integer
   uc.SetDefaultDataType(BuiltInType::Integer_32);
   cout << "New: " << uc.DefaultDataType().Name() << endl;

   // 3. Reset to Double using string shortcut
   uc.SetDefaultDataType("Double");
   cout << "Reset: " << uc.DefaultDataType().Name() << endl;

}
				
			
Start: double
New: int
Reset: double
				
					Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// 1. Check startup default (usually Double)
      Console.WriteLine($"Start: {uc.DefaultDataType.Name}")
      
      '// 2. Change default to 32-bit Integer
      uc.SetDefaultDataType(BuiltInType.Integer_32)
      Console.WriteLine($"New: {uc.DefaultDataType.Name}")
      
      '// 3. Reset to Double using string shortcut
      uc.SetDefaultDataType("Double")
      Console.WriteLine($"Reset: {uc.DefaultDataType.Name}")
      
   End Sub
End Module
				
			
Start: double
New: int
Reset: double
Internal Test: Default Type Scope and Isolation
				
					using uCalcSoftware;

var uc = new uCalc();
// Create a separate instance to verify isolation
var uc2 = new uCalc();

// Set main instance to String
uc.SetDefaultDataType("String");

// Set second instance to Int32
uc2.SetDefaultDataType("Int32");

Console.WriteLine($"uc1 Default: {uc.DefaultDataType.Name}");
Console.WriteLine($"uc2 Default: {uc2.DefaultDataType.Name}");

uc2.DefineFunction("Add(a, b) = a + b");
Console.WriteLine($"Numeric Add: {uc2.EvalStr("Add(5, 5)")}");

// Check Eval behavior with String default
// "5" + "5" should be string concatenation "55"
uc.DefineFunction("Add(a, b) = a + b");
Console.WriteLine($"String Add: {uc.EvalStr("Add(5, 5)")}");
				
			
uc1 Default: string
uc2 Default: int
Numeric Add: 10
String Add: 55
				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

int main() {
   uCalc uc;
   // Create a separate instance to verify isolation
   uCalc uc2;

   // Set main instance to String
   uc.SetDefaultDataType("String");

   // Set second instance to Int32
   uc2.SetDefaultDataType("Int32");

   cout << "uc1 Default: " << uc.DefaultDataType().Name() << endl;
   cout << "uc2 Default: " << uc2.DefaultDataType().Name() << endl;

   uc2.DefineFunction("Add(a, b) = a + b");
   cout << "Numeric Add: " << uc2.EvalStr("Add(5, 5)") << endl;

   // Check Eval behavior with String default
   // "5" + "5" should be string concatenation "55"
   uc.DefineFunction("Add(a, b) = a + b");
   cout << "String Add: " << uc.EvalStr("Add(5, 5)") << endl;
}
				
			
uc1 Default: string
uc2 Default: int
Numeric Add: 10
String Add: 55
				
					Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Create a separate instance to verify isolation
      Dim uc2 As New uCalc()
      
      '// Set main instance to String
      uc.SetDefaultDataType("String")
      
      '// Set second instance to Int32
      uc2.SetDefaultDataType("Int32")
      
      Console.WriteLine($"uc1 Default: {uc.DefaultDataType.Name}")
      Console.WriteLine($"uc2 Default: {uc2.DefaultDataType.Name}")
      
      uc2.DefineFunction("Add(a, b) = a + b")
      Console.WriteLine($"Numeric Add: {uc2.EvalStr("Add(5, 5)")}")
      
      '// Check Eval behavior with String default
      '// "5" + "5" should be string concatenation "55"
      uc.DefineFunction("Add(a, b) = a + b")
      Console.WriteLine($"String Add: {uc.EvalStr("Add(5, 5)")}")
   End Sub
End Module
				
			
uc1 Default: string
uc2 Default: int
Numeric Add: 10
String Add: 55
Previous
Next