uCalc SDK Interactive Examples

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      '// Create two separate uCalc instances&#13;      Dim uc1 As New uCalc()&#13;      Dim uc2 As New uCalc()&#13;      &#13;      '// Parse the same expression string in both instances&#13;      Dim expr1 = uc1.Parse("1 + 1")&#13;      Dim expr2 = uc2.Parse("1 + 1")&#13;      &#13;      '// Use the .uCalc() method and MemoryIndex to verify ownership&#13;      Console.WriteLine($"expr1 belongs to uc1: {expr1.uCalc.MemoryIndex = uc1.MemoryIndex}")&#13;      Console.WriteLine($"expr2 belongs to uc2: {expr2.uCalc.MemoryIndex = uc2.MemoryIndex}")&#13;      Console.WriteLine($"expr1 does not belong to uc2: {expr1.uCalc.MemoryIndex <> uc2.MemoryIndex}")&#13;   End Sub&#13;End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      '// Capture the string and show both versions in the replacement
      t.FromTo("{@String:txt}", "With: {txt(0)}, Without: {txt(1)}, Default: {txt}")
      
      Console.WriteLine(t.Transform("'uCalc'"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Console.WriteLine(uc.DataTypeOf("2 * (3 + 4)").IsCompound)
      Console.WriteLine(uc.DataTypeOf(" 'Hello ' + 'world!' ").IsCompound)
      Console.WriteLine(uc.DataTypeOf("3 + 4 * #i").IsCompound)
      Console.WriteLine(uc.DataTypeOf(BuiltInType.String).IsCompound)
      Console.WriteLine(uc.DataTypeOf("Bool").IsCompound)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub ItemCallback(ByVal cb As uCalc.Callback)
      Console.WriteLine($"Name: {cb.Item.Name}")
      Console.WriteLine($"Data type: {cb.Item.DataType.Name}")
      Console.WriteLine($"Param count: {cb.Item.Count}")
      Console.Write("Procedure type: ")
      If cb.Item.IsProperty(ItemIs.Operator) Then
         Console.WriteLine("Operator")
         ElseIf cb.Item.IsProperty(ItemIs.Function ) Then
            Console.WriteLine("Function")
         End If
         Console.WriteLine(cb.Item.Text)
         Console.WriteLine(cb.Item.Description)
         Console.WriteLine("---")
      End Sub
      Public Sub Main()
         Dim uc As New uCalc()
         
         uc.DefineFunction("AAA() As Double", AddressOf ItemCallback).Description = "Does this and that"
         uc.DefineFunction("BBB(x, y, z) As String", AddressOf ItemCallback).Description = "Does something else"
         uc.DefineOperator("{x} CCC {y} As Int32", 0, Associativity.LeftToRight, AddressOf ItemCallback)
         
         uc.EvalStr("AAA()")
         uc.EvalStr("BBB(9, 8, 7)")
         uc.EvalStr("5 CCC 4")
         
      End Sub
   End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      uc.DefineVariable("MyVar")
      
      Console.WriteLine($"{uc.EvalStr("'Cos is a function? '")}{uc.ItemOf("Cos").IsProperty(ItemIs.Function)}")
      Console.WriteLine($"{uc.EvalStr("'Cos is a variable? '")}{uc.ItemOf("Cos").IsProperty(ItemIs.Variable)}")
      Console.WriteLine($"{uc.EvalStr("'Cos is an operator? '")}{uc.ItemOf("Cos").IsProperty(ItemIs.Operator)}")
      Console.WriteLine($"{uc.EvalStr("'MyVar is a function? '")}{uc.ItemOf("MyVar").IsProperty(ItemIs.Function)}")
      Console.WriteLine($"{uc.EvalStr("'MyVar is a variable? '")}{uc.ItemOf("MyVar").IsProperty(ItemIs.Variable)}")
      Console.WriteLine($"{uc.EvalStr("'MyVar is an operator? '")}{uc.ItemOf("MyVar").IsProperty(ItemIs.Operator)}")
      Console.WriteLine($"{uc.EvalStr("'+ is a function? '")}{uc.ItemOf("+").IsProperty(ItemIs.Function)}")
      Console.WriteLine($"{uc.EvalStr("'+ is a variable? '")}{uc.ItemOf("+").IsProperty(ItemIs.Variable)}")
      Console.WriteLine($"{uc.EvalStr("'+ is an operator? '")}{uc.ItemOf("+").IsProperty(ItemIs.Operator)}")
      Console.WriteLine($"{uc.EvalStr("'Cos not found? '")}{uc.ItemOf("Cos").IsProperty(ItemIs.NotFound)}")
      Console.WriteLine($"{uc.EvalStr("'XYZABC not found? '")}{uc.ItemOf("XYZABC").IsProperty(ItemIs.NotFound)}")
   End Sub
End Module

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      '// String results will be surrounded by << and >>, while Boolean will be surrounded by [[ and ]]&#13;      uc.Format("DataType: String, Def: val = '<<' + val + '>>' ")&#13;      uc.Format("Bool, val = '[[' + val + ']]'") '// Shortcut notation without "DataType" or "Def"&#13;      &#13;      Console.WriteLine(uc.EvalStr("10+20"))&#13;      Console.WriteLine(uc.EvalStr("'Hello '+'world'"))&#13;      Console.WriteLine(uc.EvalStr("5 > 10"))&#13;      Console.WriteLine(uc.EvalStr("5 < 10"))&#13;      &#13;      uc.FormatRemove()&#13;      Console.WriteLine("---")&#13;      Console.WriteLine(uc.EvalStr("10+20"))&#13;      Console.WriteLine(uc.EvalStr("'Hello '+'world'"))&#13;      Console.WriteLine(uc.EvalStr("5 > 10"))&#13;      Console.WriteLine(uc.EvalStr("5 < 10"))&#13;   End Sub&#13;End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub SharedCallback(ByVal cb As uCalc.Callback)
      Console.WriteLine($"Callback triggered by: {cb.Item.Name}")
   End Sub
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define two different symbols that use the same callback
      uc.DefineFunction("FuncA(x, y)", AddressOf SharedCallback)
      uc.DefineOperator("{x} OpB {y}", 100, Associativity.LeftToRight, AddressOf SharedCallback)
      
      '// Call both symbols
      uc.EvalStr("FuncA(1, 2)")
      uc.EvalStr("1 OpB 2")
      
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub MyAverage(ByVal cb As uCalc.Callback)
      Dim Total As Double = 0
      For x  As Integer = 1 To cb.ArgCount()
         Total = Total + cb.Arg(x)
      Next
      cb.Return(Total / cb.ArgCount())
   End Sub
   Public Sub Main()
      Dim uc As New uCalc()
      Dim MyArrayA = uc.DefineVariable("MyArrayA[] = {10, 20, 30, 40, 50}")
      Dim MyArrayB = uc.DefineVariable("MyArrayB[15]")
      Dim FunctionA = uc.DefineFunction("FuncA(x, y, z) = x + y + z")
      Dim FunctionB = uc.DefineFunction("FuncB(x, y, a = 12, b = 34) = x+y+a+b")
      Dim FunctionC = uc.DefineFunction("FuncC(x, y ...)", AddressOf MyAverage)
      Dim FunctionD = uc.DefineFunction("FuncD() = 1+1")
      
      Console.WriteLine($"Elements in MyArrayA: {MyArrayA.Count}")
      Console.WriteLine($"Elements in MyArrayB: {MyArrayB.Count}")
      Console.WriteLine($"Params in FuncA(): {FunctionA.Count}")
      Console.WriteLine($"Params in FuncB(): {FunctionB.Count}")
      Console.WriteLine($"Params in FuncC(): {FunctionC.Count}") '// -1 or 2^n-1 (n=32 or 64)
      Console.WriteLine($"Params in FuncD(): {FunctionD.Count}")
      Console.WriteLine($"Operands in ! operator: {uc.ItemOf("!").Count}")
      Console.WriteLine($"Operands in > operator: {uc.ItemOf(">").Count}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim VariableX = uc.DefineVariable("x As Int")
      Dim ParsedExpr = uc.Parse("x + 125", "Int8u")
      
      For x  As Integer = 1 To 10
         VariableX.ValueInt32(x)
         Console.WriteLine($"x = {x}  Int8 result = {uc.ValueAt(ParsedExpr.EvaluateVoid(), "Int8")}")
      Next
      
      ParsedExpr.Release()
      VariableX.Release()
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim VariableX = uc.DefineVariable("x")
      Dim ParsedExpr = uc.Parse("x * #i + 5", "Complex")
      
      For x  As Double = 1 To 10
         VariableX.Value(x)
         '// Note: EvaluateStr works with any data type;
         Console.WriteLine(uc.EvalStr("$'x = {x}  Result = '") + ParsedExpr.EvaluateStr())
      Next
      
      ParsedExpr.Release()
      VariableX.Release()
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim VariableX = uc.DefineVariable("x")
      
      Dim ParsedExpr = uc.Parse("x / 2", "Integer") '// Causes output of "x / 2" to convert to an integer
      
      '// NOTE: EvaluateInt32 should only be used when Parse() explicitly specifies Integer
      '// (Or Int, or Int32) as the second argument, or if the expression evaluates to an integer
      '// (such as evaluating a variable that was explicitly defined as integer;
      '// other arithmetic operators typically evaluate to Double floating point).
      
      For x  As Double = 1 To 10
         VariableX.Value(x)
         Console.WriteLine("x = " + VariableX.ValueStr() + "  Result = " + (ParsedExpr.EvaluateInt32()).ToString())
      Next
      
      ParsedExpr.Release()
      VariableX.Release()
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim VariableX = uc.DefineVariable("x As Int32")
      Dim MyStringVar = uc.DefineVariable("MyString = 'Hello world'")
      Dim ParsedExpr = uc.Parse("SubStr(MyString, x, 1)")
      Dim StrLength = uc.Eval("Length(MyString)")
      
      For x  As Integer = 0 To uc.Eval("Length(MyString) - 1")
         VariableX.ValueInt32(x)
         Console.Write(ParsedExpr.EvaluateStr() + ".")
      Next
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Console.WriteLine(uc.Parse(" 3 + 6 * 10 ").DataType.Name)
      Console.WriteLine(uc.Parse(" 'This ' + 'is a string' ").DataType.Name)
      Console.WriteLine(uc.Parse(" 2 + 8 * #i / 2").DataType.Name)
      Console.WriteLine(uc.Parse(" 10 + 2 > 3").DataType.Name)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Lists all tokens currently defined for the expression evaluator.
      
      Console.WriteLine($"Token Count: {uc.ExpressionTokens.Count}")
      Console.WriteLine("")
      Console.WriteLine("Index  Type  Name: regex")
      Console.WriteLine("========================")
      Dim Tokens = uc.ExpressionTokens
      For Each token In Tokens
         Console.Write(Tokens.IndexOf(token))
         Console.WriteLine($"  {token.Description}  {token.Name}: {token.Regex}")
      Next
      
      '// Note that the expression evaluator token list has a few extra tokens,
      '// related to hex/bin/oct notation, string interpolation, and imaginary number
      '// notation, which are not found in the default Transformer token list.
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim uc1 As New uCalc()
      Dim uc2 As New uCalc()
      
      Dim x1 = uc1.DefineVariable("x = 5")
      Dim x2 = uc2.DefineVariable("x = 6")
      
      Console.WriteLine(x1.uCalc.Eval("x*10")) '// Same as uc1.Eval("x*10")
      Console.WriteLine(x2.uCalc.Eval("x*10")) '// Same as uc2.Eval("x*10")
      
      uc1.Release()  '// Since x1 is part of uc1, x1 is automatically released as well
      uc2.Release()  '// Since x2 is part of uc2, x2 is automatically released as well
      
      '// You should no longer use x1 or x2 because they were part of uc1 & uc2
      '// Don not try x1.uCalc().Eval("x*10"); or x2.uCalc().Eval("x*10");
   End Sub
End Module

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      Dim t As New uCalc.Transformer()&#13;      Dim source = "<data>&#13;  content spans&#13;  multiple lines&#13;</data>"&#13;      t.FromTo("<data>{body}</data>", "Body: [{body}]")&#13;      &#13;      Console.WriteLine("--- Before: Newline is a Separator ---")&#13;      Console.WriteLine(t.Transform(source))&#13;      &#13;      '// Use ByName to find the newline token and change its type.&#13;      t.Tokens.ByName("_token_newline", TokenType.Whitespace)&#13;      &#13;      Console.WriteLine("")&#13;      Console.WriteLine("--- After: Newline is Whitespace ---")&#13;      Console.WriteLine(t.Transform(source))&#13;   End Sub&#13;End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub ErrorHandlerA(ByVal h As Handle_uCalc)
      Dim uc As New uCalc(h)
      Console.WriteLine("Handler A called")
   End Sub
   
   Public Sub ErrorHandlerB(ByVal h As Handle_uCalc)
      Dim uc As New uCalc(h)
      Console.WriteLine("Handler B called")
   End Sub
   
   Public Sub ErrorHandlerC(ByVal h As Handle_uCalc)
      Dim uc As New uCalc(h)
      Console.WriteLine("Handler C called")
   End Sub
   
   Public Sub ErrorHandlerD(ByVal h As Handle_uCalc)
      Dim uc As New uCalc(h)
      Console.WriteLine("Handler D called")
   End Sub
   
   Public Sub ErrorHandlerE(ByVal h As Handle_uCalc)
      Dim uc As New uCalc(h)
      Console.WriteLine("Handler E called")
   End Sub
   
   Public Sub Main()
      Dim uc As New uCalc()
      uc.Error.AddHandler(AddressOf ErrorHandlerA)
      uc.Error.AddHandler(AddressOf ErrorHandlerB)
      uc.Error.AddHandler(AddressOf ErrorHandlerC)
      uc.Error.AddHandler(AddressOf ErrorHandlerD, -1)
      uc.Error.AddHandler(AddressOf ErrorHandlerE, 3)
      
      Console.WriteLine(uc.EvalStr("10 / "))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   '// This error handler allows you to use variables that were not
   '// explicitly defined previously, by defining the unrecognized identifiers
   '// as variables instead of returning an error
   Public Sub AutoVariableDef(ByVal h As Handle_uCalc)
      Dim uc As New uCalc(h)
      If uc.Error.Code = ErrorCode.Undefined_Identifier Then
         uc.DefineVariable(uc.Error.Symbol)
         uc.Error.Response = ErrorHandlerResponse.Resume
      End If
   End Sub
   
   Public Sub Main()
      Dim uc As New uCalc()
      uc.Error.AddHandler(AddressOf AutoVariableDef)
      Console.WriteLine(uc.Eval("AutoTest = 123"))
      Console.WriteLine(uc.Eval("AutoTest * 1000"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// The int return value type in MyExprB is converted to
      '// Double with .Evaluate(), but not with .EvaluateDbl()
      Dim MyExprA = uc.Parse("3.2 + 5.2")
      Dim MyExprB = uc.Parse("int(3.2 + 5.2)")
      
      Console.WriteLine(MyExprA.Evaluate())
      Console.WriteLine(MyExprA.EvaluateDbl() = 8.4)
      Console.WriteLine(MyExprB.Evaluate())
      Console.WriteLine(MyExprB.EvaluateDbl() = 8)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      
      Dim VariableX = uc.DefineVariable("x")
      Dim ParsedExpr = uc.Parse("x > 3") '// The > operation returns a Boolean instead of the default floating point
      
      For x  As Double = 1 To 5
         VariableX.Value(x)
         Console.WriteLine($"x = {VariableX.ValueStr()}  x > 3 is {ParsedExpr.EvaluateBool()}")
      Next
      
      ParsedExpr.Release()
      VariableX.Release()
   End Sub
End Module

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      uc.DefineVariable("status = 'Active'")&#13;      uc.DefineVariable("login_attempts = 2")&#13;      uc.DefineVariable("is_admin = false")&#13;      &#13;      Dim rule = "(status == 'Active' AND login_attempts < 3) OR is_admin == true"&#13;      &#13;      Console.WriteLine($"Evaluating rule: {rule}")&#13;      Console.Write("Result: ")&#13;      Console.WriteLine(uc.EvalStr(rule))&#13;   End Sub&#13;End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Console.WriteLine(uc.EvalStr("10 * 5 + 3"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// See EvalStr for more examples.
      
      Console.WriteLine(uc.Eval("1+1"))
      Console.WriteLine(uc.Eval("5*(3+9)^2"))
      Console.WriteLine(uc.Eval("Length('This is a test')"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      uc.DefineVariable("x = 123")
      uc.DefineVariable("y")
      
      Console.WriteLine(uc.EvalStr("1 + 1"))
      Console.WriteLine(uc.EvalStr("UCase('Hello ' + 'world!')"))
      Console.WriteLine(uc.EvalStr("$'Interpolation: {2+3}'"))
      Console.WriteLine(uc.EvalStr("#b101 + #hAE"))
      Console.WriteLine(uc.EvalStr("Hex(1234)"))
      Console.WriteLine(uc.EvalStr("(3+5*#i)^2"))
      Console.WriteLine(uc.EvalStr("3 > 4"))
      Console.WriteLine(uc.EvalStr("Max(5, 10, 3, -5)"))
      Console.WriteLine(uc.EvalStr("x * 10"))
      uc.EvalStr("x = 456")
      Console.WriteLine(uc.EvalStr("x"))
      Console.WriteLine(uc.EvalStr("2+4, 5+4, 10+20"))
      Console.WriteLine(uc.EvalStr("y=100; ForLoop(x, 1, 10, 1, y = y + x); y"))
      Console.WriteLine(uc.EvalStr("10 / "))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      uCalc.DefaultInstance.DefineVariable("x = 1.2")
      uc.DefineVariable("x = 3.2")
      
      Dim MyExprA As New uCalc.Expression()
      Dim MyExprB As New uCalc.Expression("x+4.25")
      Dim MyExprC As New uCalc.Expression("x+4.25", uCalc.DefaultInstance.DataTypeOf("int"))
      Dim MyExprD As New uCalc.Expression(uc, "x+4.25")
      
      MyExprA.Parse("x*100")
      
      Console.WriteLine(MyExprA.Evaluate())
      Console.WriteLine(MyExprB.Evaluate())
      Console.WriteLine(MyExprC.Evaluate())
      Console.WriteLine(MyExprD.Evaluate())
      
      '// Release expressions when no longer needed (see other example for auto-release)
      MyExprA.Release()
      MyExprB.Release()
      MyExprC.Release()
      MyExprD.Release()
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define a token for C-like 0x hex notation
      uc.ExpressionTokens.Add("0x[0-9A-Fa-f]+", TokenType.TokenTransform)
      uc.TokenTransformer.FromTo("{'0x'}{Num:'[0-9A-Fa-f]+'}", "BaseConvert('{Num}', 16)")
      Console.WriteLine($"0xFF is evaluated as: {uc.EvalStr("0xFF")}")
      
      '// Define a token for C++-style 0b binary notation
      uc.ExpressionTokens.Add("0b[01]+", TokenType.TokenTransform)
      
      '// Using {@Eval} is more efficient as the conversion happens once during the token transform pass.
      uc.TokenTransformer.FromTo("{'0b'}{Num:'[01]+'}", "{@Eval: BaseConvert(Num, 2)}")
      Console.WriteLine($"0b1011 is evaluated as: {uc.EvalStr("0b1011")}")
      
      '// Note: uCalc has built-in support for hex/binary using # notation (e.g., #hFF, #b1011)
      Console.WriteLine($"uCalc's built-in #hFF is: {uc.EvalStr("#hFF")}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Using s As New uCalc.String("Calculate (10 * 5) and ignore this.")
         
         '// Get the text from the opening parenthesis to the closing one.
         Dim expression = s.BetweenInclusive("(", ")")
         
         Console.WriteLine(expression)
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Using t As New uCalc.Transformer()
         '// Define a rule to find a key-value pair
         t.FromTo("{@Alphanumeric:key}={@Alphanumeric:val}", "Key: {key}, Value: {val}")
         
         '// Process a simple query string
         Console.WriteLine(t.Transform("user=admin"))
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Using s As New uCalc.String("ID: 12345")
         
         '// Get the text after the "ID: " prefix
         Dim value = s.After("ID: ")
         
         Console.WriteLine(value)
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t = uc.NewTransformer()
      '// Capture the alphanumeric key and any literal value
      t.FromTo("{@Alpha:key} = {@Literal:val}", "KEY:[{key}] VAL:[{val}]")
      
      Dim input = "Timeout = 100; User = 'Admin'"
      Console.WriteLine(t.Transform(input))
   End Sub
End Module