uCalc SDK Interactive Examples

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Console.WriteLine("--- Default Behavior (No Errors Raised) ---")
      Console.WriteLine($"1/0: {uc.EvalStr("1/0")}")
      Console.WriteLine($"0/0: {uc.EvalStr("0/0")}")
      Console.WriteLine($"Overflow (5*10^308): {uc.EvalStr("5*10^308")}")
      Console.WriteLine($"Underflow (10^-308/10000): {uc.EvalStr("10^-308/10000")}")
      
      Console.WriteLine("")
      Console.WriteLine("--- Enable Invalid Operation & Underflow ---")
      '// You can pass multiple enum members to enable them simultaneously
      uc.Error.SetFloatingPointErrorsToTrap(ErrorCode.FloatInvalid, ErrorCode.FloatUnderflow)
      Console.WriteLine($"Current flags: {uc.Error.FloatingPointErrorsToTrap}") '// Should be 16 (Invalid) + 2 (Underflow) = 18
      
      Console.WriteLine($"1/0: {uc.EvalStr("1/0")}") '// Not enabled, returns inf
      Console.WriteLine($"0/0: {uc.EvalStr("0/0")}") '// Enabled, raises error
      Console.WriteLine($"Overflow (5*10^308): {uc.EvalStr("5*10^308")}") '// Not enabled, returns inf
      Console.WriteLine($"Underflow (10^-308/10000): {uc.EvalStr("10^-308/10000")}") '// Enabled, raises error
   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()
         Dim myToken = t.Tokens.Add("###", TokenType.Generic)
         Console.Write("Initial Type: ")
         Console.WriteLine(myToken.TypeOfToken = TokenType.Generic)
         
         '// Change the type
         myToken.TypeOfToken = TokenType.Reducible
         Console.Write("New Type is Reducible: ")
         Console.WriteLine(myToken.TypeOfToken = TokenType.Reducible)
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Attempt to evaluate an expression with unbalanced parenthesis causing a syntax error.
      uc.EvalStr("5 * (10 +")
      
      '// Check the error message from the last operation.
      Console.WriteLine($"Last error message: {uc.Error.Message}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      Dim rule = t.FromTo("ERROR", "[ERR]")
      rule.GlobalMaximum = 2
      
      '// This input has 3 matches, which exceeds the maximum of 2.
      Dim input1 As String = "ERROR 1, ERROR 2, ERROR 3"
      t.Transform(input1)
      Console.WriteLine($"Input 1 Match Count: {t.Matches.Count()}") '// Expect 0
      
      '// This input has 2 matches, which is within the limit.
      Dim input2 As String = "ERROR 1, ERROR 2"
      t.Transform(input2)
      Console.WriteLine($"Input 2 Match Count: {t.Matches.Count()}") '// Expect 2
      Console.WriteLine(t)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      
      '// 1. The uCalc instance (uc) is the factory
      
      '// 2. Create a Transformer from the instance
      Using t As New uCalc.Transformer(uc)
         '// 3. Define a Rule on the transformer
         t.FromTo("apple", "FRUIT")
         
         '// 4. Process text and get the result
         Console.WriteLine(t.Transform("An apple a day."))
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      
      '// A rule to replace the alphanumeric token 'x' with 'value'
      t.FromTo("x", "value")
      
      '// The input string where 'x' appears both as a variable and inside a string
      Dim code = "if (x > 10) print(""Max value is x"");"
      
      '// The transformation correctly ignores the 'x' inside the quoted string
      Console.WriteLine(t.Transform(code))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim expr As New uCalc.Expression("3+4")
      Console.WriteLine($"Initial: {expr}") '// Implicit EvaluateStr
      
      expr = "20+100" '// Implicit Parse
      Console.WriteLine($"Reassigned: {expr}") '// Implicit EvaluateStr
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Create a transformer and perform a transformation
      Dim t = uc.NewTransformer()
      t.Text = "if (x > 3) y = x * 2; else if(x == 5) y = x - 1;"
      t.FromTo("1", "100")
      t.Transform()
      
      '// --- Interoperability and Chaining ---
      
      Dim Pattern = "if ({cond})"
      
      '// 1. Create a uCalc.String from a Transformer.
      '// 2. Chain .After() to get a "live view" of the text after the pattern.
      Dim s As New uCalc.String(t)
      Dim after_first_if = s.After(Pattern)
      Console.WriteLine(after_first_if.Text)
      
      '// 3. Chain another .After() on the child string.
      Dim after_second_if = after_first_if.After(Pattern)
      Console.WriteLine(after_second_if.Text)
      
      '// --- String to Transformer Conversion ---
      
      '// 4. Create a uCalc.String and assign it text.
      Dim s2 As New uCalc.String()
      s2 = "This is a test"
      
      '// 5. Create a Transformer from the uCalc.String to use transformer-specific methods.
      Dim t2 As New uCalc.Transformer(s2)
      Console.WriteLine(t2.Text)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub ItemCallback(ByVal cb As uCalc.Callback)
      Console.WriteLine($"Function '{cb.Item.Name}' was called.")
      Console.WriteLine($"It is defined with {cb.Item.Count} parameters.")
   End Sub
   Public Sub Main()
      Dim uc As New uCalc()
      uc.DefineFunction("MyFunc(x, y) As Double", AddressOf ItemCallback)
      uc.EvalStr("MyFunc(1, 2)")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Basic construction and evaluation using the default uCalc instance.
      Using MyExpr As New uCalc.Expression("10 * (2 + 3)")
         Console.WriteLine(MyExpr.Evaluate())
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      t.Text = "ID:100, Name:Admin, ID:200"
      
      '// Define two rules, but only one is marked as 'focusable'
      t.Pattern("ID:{@Number}").SetFocusable(true)
      t.Pattern("Name:{@Alpha}").SetFocusable(false)
      t.Find()
      
      '// Get all matches using the default option
      Dim allMatches = t.GetMatches()
      Console.WriteLine($"--- All Matches ({allMatches.Count()}) ---")
      Console.WriteLine(allMatches.Text)
      
      '// Get only the focusable matches
      Dim focusableMatches = t.GetMatches(MatchesOption.FocusableOnly)
      Console.WriteLine("")
      Console.WriteLine($"--- Focusable Matches Only ({focusableMatches.Count()}) ---")
      Console.WriteLine(focusableMatches.Text)
   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 = uc.NewTransformer()&#13;      t.FromTo("is", "<IS>")&#13;      &#13;      Console.WriteLine("--- With Default Tokens ---")&#13;      '// By default, 'is' is a whole word (token)&#13;      Console.WriteLine(t.Transform("This is a test"))&#13;      &#13;      '// Clear all default token definitions&#13;      t.Tokens.Clear()&#13;      &#13;      '// Add a new, simple token that matches any single character&#13;      t.Tokens.Add(".")&#13;      &#13;      Console.WriteLine("")&#13;      Console.WriteLine("--- After Clearing and Adding '.' Token ---")&#13;      '// Now, 'i' and 's' are matched as separate characters&#13;      t.FromTo("is", "<IS>") '// The rule must be redefined&#13;      Console.WriteLine(t.Transform("This is a test"))&#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()
      Dim tokens = t.Tokens
      
      '// Set a description
      tokens.Description = "Default token set for general purpose parsing."
      
      '// Get the description
      Console.WriteLine(tokens.Description)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      
      '// Set the description using the property setter syntax
      t.Description = "My Transformer"
      
      '// Get the description using the property getter syntax
      Console.WriteLine($"Description: {t.Description}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      t.Text = "This is a test."
      
      '// Rule 1 (defined first, lower priority)
      Dim rule1 = t.FromTo("is", "[IS_1]")
      
      '// Rule 2 (defined second, higher priority)
      Dim rule2 = t.FromTo("is", "[IS_2]")
      
      Console.WriteLine("--- Applying transform (Rule 2 has precedence) ---")
      Console.WriteLine(t.Transform())
      Console.WriteLine("")
      
      Console.WriteLine("--- Using NextOverload ---")
      '// Get the rule that comes after rule2
      Dim nextRule = rule2.NextOverload()
      
      Console.WriteLine($"Rule 2 pattern: {rule2.Pattern}")
      Console.WriteLine($"Next rule's pattern: {nextRule.Pattern}")
      
      '// Verify that the next rule is indeed rule1
      Console.WriteLine($"Next rule is rule1: {nextRule.Handle() = rule1.Handle()}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t = uc.NewTransformer()
      Dim UserText As String = "The cat saw another cat."
      t.Text = UserText
      
      '// Define a rule and hold its handle
      Dim catRule = t.FromTo("cat", "dog")
      
      Console.Write("1. Rule Active (Default): ")
      Console.WriteLine(t.Transform())
      
      '// Deactivate the rule
      catRule.Active = false
      
      '// Re-run the transform to see the change
      Console.Write("2. Rule Inactive: ")
      t.Text = UserText
      Console.WriteLine(t.Transform())
      
      '// Reactivate the rule
      catRule.Active = true
      Console.Write("3. Rule Reactivated: ")
      Console.WriteLine(t.Transform())
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      t.FromTo("a", "*a good*")
      
      '// Case 1: A match occurs, text is modified.
      t.Text = "This is a test"
      t.Transform()
      Console.WriteLine($"Modified: {t.WasModified}")
      
      '// Case 2: No match occurs, text is unchanged.
      t.Text = "This is another test"
      t.Transform()
      Console.WriteLine($"Modified: {t.WasModified}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      
      
      '// This example is meant for C# only
      Console.WriteLine("Description: My C# uCalc instance")
      Console.WriteLine("Transformer Text: Hello Again")
      
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      t.FromTo("fox", "CAT")
      
      '// The 'fox' inside the quotes is not replaced.
      Console.WriteLine(t.Transform("The quick brown fox jumps over the 'lazy fox'."))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      Dim txt As String = "start one; two end"
      
      '// Default behavior is StatementSensitive(true), so {body} stops at the semicolon
      '// and the 'end' anchor is never found. The transform fails.
      Dim rule = t.FromTo("start {body} end", "[{body}]")
      Console.WriteLine($"Sensitive (default): {t.Transform(txt)}")
      
      rule.StatementSensitive = false
      '// With StatementSensitive(false), {body} captures across the semicolon.
      Console.WriteLine($"Insensitive: {t.Transform(txt)}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t = uc.NewTransformer()
      Dim ruleA = t.FromTo("a", "A")
      Dim ruleB = t.FromTo("b", "B")
      ruleA.GlobalMinimum = 3
      
      '// Case 1: Fails (only 2 'a's)
      Console.WriteLine("--- Case 1: Fails ---")
      t.Text = "a b a b"
      t.Transform()
      Console.WriteLine($"Matches Found: {t.Matches.Count()}") '// Should be 0
      Console.WriteLine($"Result: {t}")
      
      '// Case 2: Succeeds (3 'a's)
      Console.WriteLine("")
      Console.WriteLine("--- Case 2: Succeeds ---")
      t.Text = "a b a b a"
      t.Transform()
      Console.WriteLine($"Matches Found: {t.Matches.Count()}") '// Should be 5 (3 'A's and 2 'B's)
      Console.WriteLine($"Result: {t}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      
      '// A snippet of code where 'rate' is both a variable and part of a string
      Dim source_code = "rate = 0.05; // Set default rate
print(""Current rate is: "" + rate);"
      
      Console.WriteLine("Original Code:")
      Console.WriteLine(source_code)
      Console.WriteLine("")
      
      '// Define a rule to rename the VARIABLE 'rate' to 'annual_rate'
      t.FromTo("rate", "annual_rate")
      t.SkipOver("// {text}")
      
      '// Run the transformation. The 'rate' inside the string is untouched.
      Console.WriteLine("Transformed Code:")
      Console.WriteLine(t.Transform(source_code))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// A 'NewUsing' block ensures the expression is automatically released at the end of the scope.
      '// This is the safest pattern to prevent memory leaks.
      Using expr As New uCalc.Expression("5 * 10")
         Console.WriteLine($"Result within scope: {expr.Evaluate()}")
      End Using
      
      '// The 'expr' object is now released and its handle is invalid.
      Console.WriteLine("Expression has been automatically released.")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      
      '// Turn single-line comments into whitespace tokens (to be ignored)
      t.Tokens.Add("//.*", TokenType.Whitespace)
      
      '// Define a rule to replace the alphanumeric token 'x' with 'value'
      t.FromTo("x", "value")
      
      Dim code = "x = 10; print('The max value is x.'); // x is 10 here"
      
      '// The Transformer correctly identifies that only the first 'x' is
      '// a token on its own. Imbedded occurrences of 'x' are left alone.
      Console.WriteLine(t.Transform(code))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define a variable 'x' that will be used in our expression
      Dim variableX = uc.DefineVariable("x As Int")
      
      '// Parse an expression that will result in an unsigned 8-bit integer (0-255)
      Dim parsedExpr = uc.Parse("x + 125", "Int8u")
      
      Console.WriteLine("x | Int8u (0 to 255) | Int8 (-128 to 127)")
      Console.WriteLine("------------------------------------------")
      
      For x  As Integer = 1 To 5
         variableX.ValueInt32(x)
         
         '// Evaluate the expression to get a pointer to the result
         Dim resultPtr = parsedExpr.EvaluateVoid()
         
         '// Get the raw unsigned result
         Dim unsignedResult = uc.ValueAt(resultPtr, "Int8u")
         
         '// Use ValueAt to *re-interpret* the same memory as a signed byte
         Dim signedResult = uc.ValueAt(resultPtr, "Int8")
         
         Console.WriteLine($"{x} | {unsignedResult} | {signedResult}")
      Next
      
      '// Clean up the created items
      parsedExpr.Release()
      variableX.Release()
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t = uc.ExpressionTransformer  '// Transformer used for Eval() and Evaluate()
      
      Dim p1 = t.FromTo("AddUp({x})", "{x}") '// Base case
      Dim p2 = t.FromTo("AddUp({x}, {y})", "({x} + AddUp({y}))").SetRewindOnChange(true) '// Recursive step
      
      Console.WriteLine($"p1 RewindOnChange: {p1.RewindOnChange}")
      Console.WriteLine($"p2 RewindOnChange: {p2.RewindOnChange}")
      
      Console.WriteLine("")
      Console.WriteLine($"Input: AddUp(1,2,3,4)")
      Console.WriteLine($"Transform: {t.Transform("AddUp(1,2,3,4)")}")
      Console.WriteLine($"Eval: {uc.Eval("AddUp(1,2,3,4)")}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t = uc.ExpressionTransformer
      
      '// Base case: a single argument
      t.FromTo("AddUp({x})", "{x}")
      
      '// Recursive case: multiple arguments
      '// RewindOnChange(true) causes the transformer to re-scan the string after a replacement.
      '// This allows AddUp(1,2,3) -> (1 + AddUp(2,3)) -> (1 + (2 + AddUp(3))) -> (1 + (2 + 3))
      t.FromTo("AddUp({x}, {y})", "({x} + AddUp({y}))").RewindOnChange = true
      
      Console.WriteLine("Input: AddUp(1, 2, 3, 4)")
      Console.WriteLine($"Result: {uc.Eval("AddUp(1, 2, 3, 4)")}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      
      '// Implicitly set the Text property by assigning a string to the object
      t = "user=admin; level=9; theme=dark;"
      
      '// Define a rule to extract the user value
      t.FromTo("user={name};", "Username: {name}")
      t.Transform()
      
      '// Implicitly get the Text property by using the object in a string context
      Dim result As String = t
      Console.WriteLine(result)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim text As uCalc.String = "This is foo 1, foo 2, Foo 3, foo 4"
      text.After("1").Before("3").Replace("foo", "bar") '// 'text' is now modified
      Console.WriteLine(text)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// 1. Create and configure the original transformer
      Dim t1 As New uCalc.Transformer()
      t1.FromTo("A", "B")
      Console.WriteLine($"Original Transform: {t1.Transform("A C A")}")
      
      '// 2. Clone it
      Dim t2 = t1.Clone()
      
      '// 3. Modify the clone. This does not affect the original.
      t2.FromTo("C", "D")
      Console.WriteLine($"Cloned Transform:   {t2.Transform("A C A")}")
      
      '// 4. Verify original is unchanged by re-running its transform
      Console.WriteLine($"Original is Unchanged: {t1.Transform("A C A")}")
      t2.Release()
      t1.Release()
   End Sub
End Module