uCalc SDK Interactive Examples

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;      Dim Pattern = t.Pattern("< {etc} >")&#13;      t.Str("< a b c > d < (e f g) > h < (i) (j k) > l < m n o ( > p) q >")&#13;      &#13;      '// Note the difference in the final match&#13;      &#13;      Pattern.BracketSensitive = true '// true is the default&#13;      Console.WriteLine($"BracketSensitive: {Pattern.BracketSensitive}")&#13;      Console.WriteLine("----------------------")&#13;      t.Find()&#13;      Console.WriteLine(t.Matches.Text)&#13;      Console.WriteLine("")&#13;      &#13;      Pattern.BracketSensitive = false&#13;      Console.WriteLine($"BracketSensitive: {Pattern.BracketSensitive}")&#13;      Console.WriteLine("-----------------------")&#13;      &#13;      t.Find()&#13;      Console.WriteLine(t.Matches.Text)&#13;      Console.WriteLine("")&#13;      &#13;      t.Str("( a b ( c ) d e )")&#13;      '// Here parentheses are captured as regular tokens, not bracket pairs&#13;      Dim Pattern2a = t.Pattern("( {etc} (")&#13;      Dim Pattern2b = t.Pattern(") {etc} )")&#13;      &#13;      Console.WriteLine("Brackets used as part of pattern")&#13;      Console.WriteLine("--------------------------------")&#13;      Pattern2a.BracketSensitive = true&#13;      Pattern2b.BracketSensitive = true&#13;      t.Find()&#13;      Console.WriteLine(t.Matches.Text)&#13;      Console.WriteLine("")&#13;      Pattern2a.BracketSensitive = false&#13;      Pattern2b.BracketSensitive = false&#13;      t.Find()&#13;      Console.WriteLine(t.Matches.Text)&#13;      &#13;      &#13;   End Sub&#13;End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define a function for the standard loan payment formula
      uc.DefineFunction("LoanPmt(rate, nper, pv) = Int((rate * pv) / (1 - (1 + rate)^-nper)*100)/100")
      
      '// Define variables for the calculation
      uc.DefineVariable("monthly_rate = 0.05 / 12") '// 5% annual rate
      uc.DefineVariable("periods = 30 * 12")      '// 30 years
      uc.DefineVariable("loan_amount = 200000")   '// $200,000
      
      Console.WriteLine(uc.EvalStr("LoanPmt(monthly_rate, periods, loan_amount)"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define some context for the expression
      uc.DefineVariable("price = 49.99")
      uc.DefineVariable("quantity = 3")
      uc.DefineConstant("TAX_RATE = 0.0825")
      
      '// Define a format for currency output
      uc.Format("DataType: Double, Def: result = '$' + result")
      
      '// Expression to calculate total price, using variables
      Dim expression = "price * quantity * (1 + TAX_RATE)"
      
      '// Evaluate with formatting enabled
      Console.WriteLine($"Formatted Total: {uc.EvalStr(expression, true)}")
      
      '// Evaluate with formatting disabled
      Console.WriteLine($"Raw Total: {uc.EvalStr(expression, false)}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define variables representing configuration or user inputs.
      uc.DefineVariable("principal = 20000")
      uc.DefineVariable("annual_rate = 0.0575")
      uc.DefineVariable("years = 4")
      
      '// Evaluate an expression combining these variables.
      Dim interest = uc.Eval("principal * annual_rate * years")
      Console.WriteLine($"Total Interest: {interest}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      uc.DefineVariable("principal = 5000")
      uc.DefineVariable("rate = 0.05")
      uc.DefineVariable("years = 4")
      Console.WriteLine($"Interest: {uc.EvalStr("principal * rate * years")}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Calculate a 15% discount on a price of $75
      Console.Write("Discounted price: ")
      Console.WriteLine(uc.EvalStr("75 * (1 - 0.15)"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub MyErrorHandler(ByVal h As Handle_uCalc)
      Dim uc As New uCalc(h)
      Console.WriteLine("--- Error Captured ---")
      Console.WriteLine($"Message: {uc.Error.Message}")
      Console.WriteLine($"Symbol: '{uc.Error.Symbol}'")
      Console.WriteLine($"Location: {uc.Error.Location}")
      Console.WriteLine($"Expression: '{uc.Error.Expression}'")
   End Sub
   
   Public Sub Main()
      Dim uc As New uCalc()
      uc.Error.AddHandler(AddressOf MyErrorHandler)
      
      Console.WriteLine("Demonstrating a PARSING error:")
      uc.EvalStr("123//456")
      
      Console.WriteLine("")
      Console.WriteLine("Demonstrating an EVALUATION error:")
      uc.Error.TrapOnDivideByZero = true
      uc.EvalStr("5/0")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t = uc.NewTransformer()
      t.Str("start x y z finish, StArT a b c FinISH, START 1 2 3 FINISH")
      Dim Pattern = t.Pattern("StArT {etc} FinISH")
      
      Pattern.CaseSensitive = true
      Console.WriteLine($"CaseSensitive: {Pattern.CaseSensitive}")
      Console.WriteLine("-------------------")
      t.Find()
      Console.WriteLine(t.Matches.Text)
      Console.WriteLine("")
      
      Pattern.CaseSensitive = false
      Console.WriteLine($"CaseSensitive: {Pattern.CaseSensitive}")
      Console.WriteLine("--------------------")
      t.Find()
      Console.WriteLine(t.Matches.Text)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Using url As New uCalc.String("http://example.com")
         Console.WriteLine($"Original URL: {url}")
         '// Get a view of the scheme part
         Dim schemeView = url.Before("://")
         '// Modify the view
         schemeView.Replace("http", "https")
         '// The original string is updated
         Console.WriteLine($"Modified URL: {url}")
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// (See alternate version of this example using ItemOf instead of ExpressionTokens)
      
      '// In this section underscore, _, and numeric digits
      '// are accepted as part of alphanumeric tokens
      uc.DefineVariable("My_Variable = 111")
      Console.WriteLine(uc.Error.Message)
      uc.DefineVariable("Variable123 = 222")
      Console.WriteLine(uc.Error.Message)
      
      Console.WriteLine(uc.ExpressionTokens(TokenType.AlphaNumeric).Regex)
      Console.WriteLine(uc.EvalStr("My_Variable"))
      Console.WriteLine(uc.EvalStr("Variable123"))
      Console.WriteLine("---")
      
      '// Now we no longer want underscore, _, or numeric digits
      '// to be accepted in alphanumeric tokens; only A-Z
      uc.ExpressionTokens(TokenType.AlphaNumeric).Regex = "[a-zA-Z]+"
      
      uc.DefineVariable("Other_Variable = 333")
      Console.WriteLine(uc.Error.Message)
      uc.DefineVariable("OtherVariable123 = 444")
      Console.WriteLine(uc.Error.Message)
      
      Console.WriteLine(uc.EvalStr("Other_Variable"))
      Console.WriteLine(uc.EvalStr("OtherVariable123 "))
      Console.WriteLine(uc.EvalStr("My_Variable"))
      Console.WriteLine(uc.EvalStr("Variable123"))
      Console.WriteLine("---")
      
      '// We restore the alphanumeric regex to support _ and numbers again
      '// Note: My_Variable and Variable123 remained; they were simply inaccessible
      uc.ExpressionTokens(TokenType.AlphaNumeric).Regex = "[a-zA-Z_][a-zA-Z0-9_]*"
      Console.WriteLine(uc.EvalStr("My_Variable"))
      Console.WriteLine(uc.EvalStr("Variable123"))
   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;      &#13;      t.Str("&#13;<div>a b c</div>&#13;<div>&#13;x&#13;y&#13;z&#13;</div>&#13;<div>1 2 3</div>&#13;")&#13;      &#13;      t.Pattern("<div>{body}</div>")&#13;      &#13;      Console.WriteLine("Newline as statement separator (default)")&#13;      Console.WriteLine("----------------------------------------")&#13;      Console.WriteLine(t.Find().Matches.Text)&#13;      Console.WriteLine("")&#13;      &#13;      Console.WriteLine("Newline as whitespace")&#13;      Console.WriteLine("---------------------")&#13;      t.Tokens("_token_newline").TypeOfToken = TokenType.Whitespace&#13;      Console.WriteLine(t.Find().Matches.Text)&#13;   End Sub&#13;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;      &#13;      t.Str("&#13;<div>a b c</div>&#13;<div>&#13;x&#13;y&#13;z&#13;</div>&#13;<div>1 2 3</div>&#13;")&#13;      &#13;      t.Pattern("<div>{body}</div>")&#13;      Dim NewLineToken = t.Tokens("_token_newline")&#13;      &#13;      Console.WriteLine("Newline as statement separator (default)")&#13;      Console.WriteLine("----------------------------------------")&#13;      Console.WriteLine(t.Find().Matches.Text)&#13;      Console.WriteLine("")&#13;      &#13;      Console.WriteLine("Newline as whitespace")&#13;      Console.WriteLine("---------------------")&#13;      NewLineToken.TypeOfToken = TokenType.Whitespace&#13;      Console.WriteLine(t.Find().Matches.Text)&#13;   End Sub&#13;End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// (See alternate version of this example using ExpressionTokens instead of ItemOf)
      
      '// In this section underscore, _, and numeric digits
      '// are accepted as part of alphanumeric tokens
      uc.DefineVariable("My_Variable = 111")
      Console.WriteLine(uc.Error.Message)
      uc.DefineVariable("Variable123 = 222")
      Console.WriteLine(uc.Error.Message)
      
      Console.WriteLine(uc.ItemOf("_Token_Alphanumeric").Regex)
      Console.WriteLine(uc.EvalStr("My_Variable"))
      Console.WriteLine(uc.EvalStr("Variable123"))
      Console.WriteLine("---")
      
      '// Now we no longer want underscore, _, or numeric digits
      '// to be accepted in alphanumeric tokens; only A-Z
      uc.ItemOf("_Token_Alphanumeric").Regex = "[a-zA-Z]+"
      
      uc.DefineVariable("Other_Variable = 333")
      Console.WriteLine(uc.Error.Message)
      uc.DefineVariable("OtherVariable123 = 444")
      Console.WriteLine(uc.Error.Message)
      
      Console.WriteLine(uc.EvalStr("Other_Variable"))
      Console.WriteLine(uc.EvalStr("OtherVariable123 "))
      Console.WriteLine(uc.EvalStr("My_Variable"))
      Console.WriteLine(uc.EvalStr("Variable123"))
      Console.WriteLine("---")
      
      '//
      '// We restore the alphanumeric regex to support _ and numbers again
      '// Note: My_Variable and Variable123 remained; they were simply inaccessible
      '// Also: We can't use the commented line below because it has the underscore, _,
      '// character that we had removed.
      '// uc.ItemOf("_token_alphanumeric").Regex("[a-zA-Z_][a-zA-Z0-9_]*");
      uc.ExpressionTokens(TokenType.AlphaNumeric).Regex = "[a-zA-Z_][a-zA-Z0-9_]*"
      Console.WriteLine(uc.EvalStr("My_Variable"))
      Console.WriteLine(uc.EvalStr("Variable123"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim MyVar = uc.DefineVariable("x = 100")
      Console.WriteLine(uc.EvalStr("x"))
      
      uc.EvalStr("x = 200")
      Console.WriteLine(uc.EvalStr("x")) '// x can change here
      
      '// Locking an item prevents it from being changed
      MyVar.IsProperty(ItemIs.Locked, true)
      
      uc.EvalStr("x = 300") '// x cannot change here
      Console.WriteLine(uc.EvalStr("x")) '// x retains the previous value
      
      
      
      
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      uc.DefineVariable("x = 1")
      uc.DefineVariable("y = 2")
      uc.DefineFunction("f(x) = x * 10")
      
      Dim t = uc.NewTransformer()
      Dim text = "Adding {x} and {y} gives: {x + y}. f(5) = {f(5)}"
      
      Dim uNew As New uCalc()
      uNew.DefineVariable("x = 111")
      uNew.DefineVariable("y = 222")
      uNew.DefineFunction("f(x) = x * 1000")
      
      '// Note: {@@Eval: txt} is equivalent of {@Eval: Eval(txt)}
      '// which is what's needed for to evaluate the expression
      '// resulting from the match that is not known ahead of time
      t.FromTo("'{' {expr} '}'", "{@@Eval: expr}")
      Console.WriteLine(t.Transform(text))
      
      t.uCalc = uNew
      t.FromTo("'{' {expr} '}'", "{@@Eval: expr}")
      Console.WriteLine(t.Transform(text))
      
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim Status = uc.DefineVariable("Status As Bool")
      Console.WriteLine(Status.ValueBool())
      
      Dim MyuCalc As New uCalc()
      
      Status.ValueBool(MyuCalc.IsDefault)
      Console.WriteLine(uc.EvalStr("$'MyuCalc is the current default? {Status}'"))
      
      MyuCalc.IsDefault = true
      Status.ValueBool(MyuCalc.IsDefault)
      
      Console.WriteLine(uc.EvalStr("$'MyuCalc is the current default? {Status}'"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim result = uc.Eval("MyVar * 10")
      Console.WriteLine("An error has occurred!")
      Console.WriteLine($"Error #: {CInt(uc.Error.Code)}")
      Console.WriteLine($"Error Message: {uc.Error.Message}")
      Console.WriteLine($"Error Location: {uc.Error.Location}")
      Console.WriteLine($"Error Expression: {uc.Error.Expression}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub MyHandler(ByVal h As Handle_uCalc)
      Dim uc As New uCalc(h)
      '// Retrieve the error code as an integer for display
      Dim code As Integer = uc.Error.Code
      Console.WriteLine($"Caught Error Code: {code}")
      
      '// Compare the error code against the ErrorCode enum for logic
      If uc.Error.Code = ErrorCode.Syntax_Error Then
         Console.WriteLine("This was a syntax error.")
      End If
   End Sub
   
   Public Sub Main()
      Dim uc As New uCalc()
      '// Register the error handler
      uc.Error.AddHandler(AddressOf MyHandler)
      
      '// Intentionally cause a syntax error, which will trigger the handler
      Console.WriteLine(uc.EvalStr("5 *"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define a variable with a specific type
      uc.DefineVariable("myVar As Int16")
      
      '// Retrieve the generic Int16 type object
      Dim typeObj = uc.DataTypeOf(BuiltInType.Integer_16)
      
      '// Check if the variable's type matches Int16
      If uc.ItemOf("myVar").DataType.BuiltInTypeEnum = typeObj.BuiltInTypeEnum Then
         Console.WriteLine("Variable 'myVar' is an Int16.")
      Else
         Console.WriteLine("Type mismatch.")
      End If
   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 text_ok = "Header: OK"
         Dim text_fail = "Header: ERROR"
         
         '// This rule only matches if the status is "OK"
         t.Pattern("Header: OK")
         
         '// Find() returns the transformer, so we can chain Matches().Count()
         If t.SetText(text_ok).Find().Matches.Count() > 0 Then
            Console.WriteLine("text_ok is valid.")
         End If
         
         If t.SetText(text_fail).Find().Matches.Count() = 0 Then
            Console.WriteLine("text_fail is invalid.")
         End If
      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()
         Dim text_ok = "Header: OK"
         Dim text_fail = "Header: ERROR"
         
         '// This rule only matches if the status is "OK"
         t.Pattern("Header: OK")
         
         '// Find() returns the transformer, so we can chain Matches().Count()
         If t.SetText(text_ok).Find().Matches.Count() > 0 Then
            Console.WriteLine("text_ok is valid.")
         End If
         
         If t.SetText(text_fail).Find().Matches.Count() = 0 Then
            Console.WriteLine("text_fail is invalid.")
         End If
      End Using
   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 array (from initializer): {MyArrayA.Count}")
      Console.WriteLine($"Elements in array (from size): {MyArrayB.Count}")
      Console.WriteLine($"Parameters in FuncA() (fixed): {FunctionA.Count}")
      Console.WriteLine($"Parameters in FuncB() (with optional): {FunctionB.Count}")
      Console.WriteLine($"Parameters in FuncC() (variadic): {FunctionC.Count}")
      Console.WriteLine($"Parameters in FuncD() (none): {FunctionD.Count}")
      Console.WriteLine($"Operands in '!' operator (postfix): {uc.ItemOf("!").Count}")
      Console.WriteLine($"Operands in '>' operator (infix): {uc.ItemOf(">").Count}")
   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()
         '// Rule to convert legacy variable declaration
         t.FromTo("LET {@Alpha:var} = {val}", "var {var} = {val};")
         Console.WriteLine(t.Transform("LET X = 100"))
      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()
      
      '// Define the pattern first
      t.FromTo("Temperature: {temp} C", "temperature: {@Eval: Double(temp) * 1.8 + 32} F")
      
      '// Perform the Transform() operation
      Console.WriteLine(t.Transform("Here is the temperature: 22.5 C"))
   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;      '// Use {s(1)} to get just the text inside the quotes&#13;      t.FromTo("msg = {@String:s}", "<message>{s(1)}</message>")&#13;      &#13;      Dim input As String = "msg = ""Welcome to uCalc!"""&#13;      Console.WriteLine(t.Transform(input))&#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()
      t.FromTo("{@sq}", """")
      
      Console.WriteLine(t.Transform("print 'Hello'"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      
      ' 1. Automatic resource management with 'Using '
Using u = New uCalc()
    ' 2. Property syntax for setting the description
    u.Description = "My VB.NET uCalc instance"
         Console.WriteLine($"Description: {u.Description}")
         
         ' 3. Implicit String conversion for Transformer.Text
    Dim t As New uCalc.Transformer()
    t.Text = "Hello World" ' Standard assignment
         t = "Hello Again"    ' Implicit conversion assignment
         Console.WriteLine($"Transformer Text: {t.Text}")
         Console.WriteLine($"Transformer Text: {t}")
      End Using
      
      
   End Sub
End Module

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   &#13;   Public Sub MyIIf(ByVal cb As uCalc.Callback)&#13;      Dim condition = cb.ArgBool(1)&#13;      Dim thenPart = cb.ArgExpr(2)&#13;      Dim elsePart = cb.ArgExpr(3)&#13;      &#13;      If condition Then&#13;         cb.Return(thenPart.Evaluate())&#13;      Else&#13;         cb.Return(elsePart.Evaluate())&#13;      End If&#13;   End Sub&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      uc.DefineFunction("MyIIf(cond As Bool, ByExpr thenExpr, ByExpr elseExpr)", AddressOf MyIIf)&#13;      &#13;      '// The 'else' branch contains 1/0, but since the condition is true,&#13;      '// it is never evaluated.&#13;      Console.WriteLine(uc.Eval("MyIIf(10 > 5, 100, 1/0)"))&#13;      &#13;      '// The 'then' branch contains 1/0, but it is never evaluated.&#13;      Console.WriteLine(uc.Eval("MyIIf(10 < 5, 1/0, 200)"))&#13;   End Sub&#13;End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Use the ExpressionTransformer for multi-word syntax.
      Dim t = uc.ExpressionTransformer
      
      '// Note: Captured variables are passed to @Eval as text
      '// Double() converts the text to Double a precision value
      uc.Format("Result = Format('{:.2f}', Double(Result))", uc.DataTypeOf("Double"))
      t.FromTo("{@Number:amount} USD to EUR", "({@Eval: Double(amount) * 0.92})")
      t.FromTo("{@Number:amount} EUR to USD", "({@Eval: Double(amount) / 0.92})")
      
      Console.WriteLine($"100 USD is approx. {uc.EvalStr("100 USD to EUR")} EUR")
      Console.WriteLine($"120 EUR is approx. {uc.EvalStr("120 EUR to USD")} USD")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      
      uc.DefineVariable("MyVar = 100")
      uc.DefineFunction("MyFunc(x) = x + 1")
      
      Dim Cloned_uc = uc.Clone()
      
      Console.WriteLine(uc.EvalStr("MyVar"))
      Console.WriteLine(uc.EvalStr("MyFunc(10)"))
      
      Console.WriteLine(Cloned_uc.EvalStr("MyVar"))
      Console.WriteLine(Cloned_uc.EvalStr("MyFunc(10)"))
      
      Cloned_uc.Eval("MyVar = 200")
      Cloned_uc.DefineFunction("OtherFunc(x) = x * 10")
      
      Console.WriteLine(uc.EvalStr("MyVar"))
      Console.WriteLine(uc.EvalStr("OtherFunc(5)"))
      
      Console.WriteLine(Cloned_uc.EvalStr("MyVar"))
      Console.WriteLine(Cloned_uc.EvalStr("OtherFunc(5)"))
   End Sub
End Module