### Install MathConverter via Package Manager

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Commands to install the required NuGet packages for WPF or MAUI projects.

```powershell
PM> Install-Package MathConverter
PM> Install-Package MathConverter.Maui
```

--------------------------------

### Basic MathConverter Setup in XAML

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Add MathConverter to your resources and use it with a Binding by specifying a ConverterParameter expression.

```xaml
<Window xmlns:math="http://hexinnovation.com/math">
    <Window.Resources>
        <math:MathConverter x:Key="Math" />
    </Window.Resources>

    <!-- Simple arithmetic: divide ActualHeight by 2 -->
    <Border CornerRadius="{Binding ActualHeight,
        ConverterParameter=x/2,
        Converter={StaticResource Math}}" />

    <!-- Exponent operator: x squared -->
    <TextBlock Text="{Binding Value,
        ConverterParameter=x^2,
        Converter={StaticResource Math}}" />

    <!-- Implicit multiplication: 2 times x -->
    <TextBlock Text="{Binding Value,
        ConverterParameter=2x,
        Converter={StaticResource Math}}" />
</Window>
```

--------------------------------

### Perform Basic Math in Binding

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Examples of using MathConverter to perform arithmetic operations on binding values.

```xml
<Border CornerRadius={Binding ActualHeight}" … />
```

```xml
<Border CornerRadius="{Binding ActualHeight, ConverterParameter=x/2, Converter={StaticResource Math}}" … />
```

--------------------------------

### String Searching with StartsWith and Contains

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Check if a string starts with a specific prefix or contains a substring. The result can be used for conditional visibility.

```xaml
<TextBlock Visibility="{Binding Text,
    ConverterParameter='StartsWith(x, `Hello`) ? `Visible` : `Collapsed`',
    Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Visibility="{Binding Text,
    ConverterParameter='Contains(x, `error`) ? `Visible` : `Collapsed`',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Format Function Example

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Demonstrates the equivalence of interpolated strings and the Format function. The interpolated string $`Hello, {x}` is equivalent to Format('Hello, {0}', x).

```C#
Format('Hello, {0}', x)
```

--------------------------------

### Get Current Date and Time

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Retrieve the current date and time using the `Now()` function. The output can be formatted using string interpolation.

```xaml
<TextBlock Text="{Binding Dummy,
    ConverterParameter='$`Current time: {Now():HH:mm:ss}`',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Perform Single Binding Conversion

Source: https://github.com/hexinnovation/mathconverter/blob/main/Nuget README.md

Use MathConverter for single binding conversions by specifying the conversion logic in the ConverterParameter. This example divides the ActualHeight by 2.

```xaml
<Border CornerRadius="{Binding ActualHeight, ConverterParameter=x/2, Converter={StaticResource Math}}" />
```

--------------------------------

### Specify Different Margins with MathConverter

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Use MathConverter with multiple values for types like Thickness by separating values with commas or semicolons in the ConverterParameter. This example sets different left/right and top/bottom margins.

```xaml
<Rectangle Fill="Green" ... Margin="{Binding Source={StaticResource Margin}, ConverterParameter=0;x, Converter={StaticResource Math}}" />
```

--------------------------------

### String Interpolation with ConverterParameter

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Use ConverterParameter with string interpolation for dynamic text formatting in bindings. The example shows how to format a string based on a bound property 'NumClicks'.

```XAML
<TextBlock Text="{Binding NumClicks, ConverterParameter='$`You have clicked the button {x} time{(x == 1 ? `` : `s`)}.`', Converter={StaticResource Math}}" />
```

--------------------------------

### MathConverter with Optional ConverterParameter

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

When ConverterParameter is omitted, MathConverter joins binding values with a comma. This example demonstrates creating different Thickness values from multiple bindings.

```xaml
<Border BorderThickness="1" BorderBrush="Red">
    <Border.Margin>
        <MultiBinding Converter="{StaticResource Math}">
            <Binding Source="{StaticResource BigMargin}" />
            <Binding Source="{StaticResource SmallMargin}" />
        </MultiBinding>
    </Border.Margin>

    <!-- Green Border -->
</Border>
```

```xaml
<Border ... Margin="{math:Convert x={Binding Margin}, y={Binding SmallMargin}}" />
```

--------------------------------

### Get Type Information

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Retrieve the type of a given value using the `GetType` function. This is useful for runtime type checking or debugging.

```xaml
<TextBlock Text="{Binding Value,
    ConverterParameter='GetType(x)',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Interpolated Strings

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Interpolated strings in MathConverter function similarly to C#, allowing dynamic string formatting. They must start and end with the same quote character.

```APIDOC
## Interpolated Strings

Interpolated strings work the same way as they do in C#. The same rules apply: a string must start and end with the same character.

### Example
```
$"'Coordinates: ({x:N2},{y:N2}).'"
$"The weather outside is {x}."
`` $`Progress: {x:P} complete` ``
```

> **Note:** An interpolated string is a wrapper around a call to the `Format` function, so `$'Hello, {x}'` is equivalent to `Format('Hello, {0}', x)`.
```

--------------------------------

### Use Convert MarkupExtension

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

A more concise syntax for performing multi-binding calculations using the math:Convert extension.

```xml
CornerRadius="{math:Convert 'Min(x,y)/2', x={Binding ActualHeight}, y={Binding ActualWidth}}"
```

--------------------------------

### String Formatting with Format Function

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Format strings using placeholders and format specifiers. The `x` parameter represents the value to be formatted.

```xaml
<TextBlock Text="{Binding Value,
    ConverterParameter='Format(`Value: {0:N2}`, x)',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Configure MathConverter Options

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Adjust caching behavior and unset value handling via XAML or C# properties.

```xaml
<!-- Disable caching for memory optimization in large apps -->
<math:MathConverter x:Key="MathNoCache" UseCache="False" />

<!-- Allow UnsetValue to pass through (default is false, converts to null) -->
<math:MathConverter x:Key="MathAllowUnset" AllowUnsetValue="True" />

<!-- Per-page converter reduces memory usage vs app-wide singleton -->
<Page.Resources>
    <math:MathConverter x:Key="Math" />
</Page.Resources>
```

```csharp
// Clear cache programmatically
var math = (MathConverter)FindResource("Math");
math.ClearCache();

// Check cache setting
bool usesCaching = math.UseCache;

// Disable caching at runtime
math.UseCache = false;
```

--------------------------------

### Error Handling with TryCatch

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Execute expressions sequentially and return the result of the first one that does not throw an exception. Useful for handling potential division by zero or other errors.

```xaml
<TextBlock Text="{Binding Value,
    ConverterParameter='TryCatch(1/x, `Division by zero`)',
    Converter={StaticResource Math}}" />
```

--------------------------------

### String Functions

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Functions for case conversion, searching, formatting, and joining strings.

```APIDOC
## String Functions

### Description
Provides utilities for manipulating strings within XAML bindings, including case conversion, pattern matching, and formatting.

### Functions
- **ToUpper(x)**: Converts string to uppercase.
- **ToLower(x)**: Converts string to lowercase.
- **StartsWith(x, pattern)**: Returns boolean if string starts with pattern.
- **Contains(x, pattern)**: Returns boolean if string contains pattern.
- **Format(format, x)**: Formats a string using standard .NET format strings.
- **Concat(x, separator, y)**: Concatenates multiple values with a separator.
- **Join(separator, ...args)**: Joins multiple arguments with a specified separator.
```

--------------------------------

### Create Custom MathConverter Functions in C#

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Inherit from base classes like OneArgFunction, OneDoubleFunction, TwoArgFunction, or ArbitraryArgFunction to define custom logic.

```csharp
// Custom function that takes one argument
using HexInnovation;
using System;
using System.Globalization;

public class GetWindowTitleFunction : OneArgFunction
{
    public override object? Evaluate(CultureInfo cultureInfo, object? argument)
    {
        return argument is Type t && t.IsAssignableTo(typeof(Window))
            ? ((Window)Activator.CreateInstance(t)!).Title
            : null;
    }
}

// Custom function with numeric input
public class DoubleValueFunction : OneDoubleFunction
{
    public override double? Evaluate(CultureInfo cultureInfo, double x)
    {
        return x * 2;
    }
}

// Custom function with two arguments
public class PowerFunction : TwoArgFunction
{
    public override object? Evaluate(CultureInfo cultureInfo, object? x, object? y)
    {
        if (TryConvert<double>(x, out var baseVal) && TryConvert<double>(y, out var exp))
            return Math.Pow(baseVal, exp);
        return null;
    }
}

// Custom function with variable arguments
public class SumFunction : ArbitraryArgFunction
{
    public override object? Evaluate(CultureInfo cultureInfo, Func<object?>[] arguments)
    {
        double sum = 0;
        foreach (var arg in arguments)
        {
            if (TryConvert<double>(arg(), out var value))
                sum += value;
        }
        return sum;
    }

    public override bool IsValidNumberOfParameters(int numParams) => numParams >= 1;
}
```

--------------------------------

### Convert Markup Extension Syntax

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

The math:Convert markup extension provides a more elegant syntax for MultiBinding scenarios, wrapping a MultiBinding internally. Up to 10 variables are supported.

```xaml
<!-- Equivalent to MultiBinding but with cleaner syntax -->
<Border CornerRadius="{math:Convert 'Min(x,y)/2',
    x={Binding ActualHeight},
    y={Binding ActualWidth}}" />
```

```xaml
<!-- Up to 10 variables supported: x, y, z, Var3 through Var9 -->
<Rectangle Fill="{math:Convert 'x > y ? `Green` : `Red`',
    x={Binding CurrentValue},
    y={Binding ThresholdValue}}" />
```

```xaml
<!-- Single variable binding -->
<TextBlock Opacity="{math:Convert 'x ? 1.0 : 0.5',
    x={Binding IsEnabled}}" />
```

--------------------------------

### Add MathConverter Resource

Source: https://github.com/hexinnovation/mathconverter/blob/main/Nuget README.md

Include the MathConverter as an Application resource to make it available throughout your application. The 'math' namespace must be defined.

```xaml
<Application.Resources>
    <math:MathConverter x:Key="Math" />
</Application.Resources>

The math namespace is defined as follows:

```xaml
xmlns:math="http://hexinnovation.com/math"
```
```

--------------------------------

### Perform MultiBinding Math

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Using MultiBinding with MathConverter to perform calculations involving multiple source properties.

```xml
<Border.CornerRadius>
    <MultiBinding ConverterParameter="Min(x,y)/2" Converter="{StaticResource Math}">
        <Binding Path="ActualHeight" />
        <Binding Path="ActualWidth" />
    </MultiBinding>
</Border.CornerRadius>
```

--------------------------------

### Registering Custom Functions in MathConverter

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

This C# code demonstrates how to dynamically manage custom functions within MathConverter. It shows how to clear existing custom functions, register default ones, or remove a default function to add a custom implementation. Use this when you need to override or extend MathConverter's built-in mathematical capabilities.

```csharp
private void RadioButton_Changed(object sender, RoutedEventArgs e)
{
    if (FindResource("Math") is not HexInnovation.MathConverter math)
        return;

    if (UseStockFunction.IsChecked == true)
    {
        // Go back to the stock function.
        math.CustomFunctions.Clear();
        math.CustomFunctions.RegisterDefaultFunctions();
    }
    else
    {
        // Remove the default Average function and define our own.
        math.CustomFunctions.Remove("Average");
        math.CustomFunctions.Add(CustomFunctionDefinition.Create<RoundedAverageFunction>("Average"));
    }

    // Tell the TextBlock to refresh its binding again.
    TextBlock?.GetBindingExpression(TextBlock.TextProperty).UpdateTarget();
}
```

--------------------------------

### Perform Multi-Binding Conversion

Source: https://github.com/hexinnovation/mathconverter/blob/main/Nuget README.md

Handle conversions involving multiple bindings by using the math:Convert markup extension. Specify the conversion expression and bind values to parameters like 'x' and 'y'.

```xaml
<Border CornerRadius="{math:Convert 'Min(x,y)/2', x={Binding ActualHeight}, y={Binding ActualWidth}}" />
```

--------------------------------

### Define ListBox items with Types

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Demonstrates adding Type objects to a ListBox for use with custom converters.

```xaml
<ListBox>
    <ListBox.Items>
        <x:Type TypeName="demos:FlattenedOval" />
        <x:Type TypeName="demos:WideRoundedRectangle" />
        <x:Type TypeName="demos:TrueRoundedRectangle" />
        <!-- More Types -->
    </ListBox.Items>

    <!-- More stuff -->
</ListBox>
```

--------------------------------

### Arithmetic Operators in MathConverter

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Use standard arithmetic operators like +, -, *, /, %, and ^ for exponentiation within XAML bindings. Ensure the converter resource is correctly defined.

```xaml
<TextBlock Text="{Binding X, ConverterParameter='x + 10', Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Text="{Binding X, ConverterParameter='x - 5', Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Text="{Binding X, ConverterParameter='x * 2', Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Text="{Binding X, ConverterParameter='x / 4', Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Text="{Binding X, ConverterParameter='x % 3', Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Text="{Binding X, ConverterParameter='x ^ 2', Converter={StaticResource Math}}" />
```

--------------------------------

### MathConverter Functions Overview

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Lists common MathConverter functions like Now(), UnsetValue(), DoNothing(), and various mathematical operations. Functions are case-sensitive.

```C#
Now()
```

```C#
UnsetValue()
```

```C#
DoNothing()
```

```C#
Cos(x)
```

```C#
Sin(x)
```

```C#
Tan(x)
```

```C#
Abs(x)
```

```C#
Acos(x)
```

```C#
ArcCos(x)
```

```C#
Asin(x)
```

```C#
ArcSin(x)
```

```C#
Atan(x)
```

```C#
ArcTan(x)
```

```C#
Ceil(x)
```

```C#
Ceiling(x)
```

```C#
Floor(x)
```

```C#
Sqrt(x)
```

```C#
Log(x, y)
```

```C#
Atan2(x, y)
```

```C#
ArcTan2(x, y)
```

```C#
Round(x)
```

```C#
Round(x, y)
```

```C#
Deg(x)
```

```C#
Degrees(x)
```

```C#
Rad(x)
```

```C#
Radians(x)
```

```C#
ToLower(x)
```

```C#
LCase(x)
```

```C#
ToUpper(x)
```

```C#
UCase(x)
```

```C#
TryParseDouble(x)
```

```C#
StartsWith(x, y)
```

```C#
EndsWith(x, y)
```

```C#
IsNull()
```

```C#
IfNull()
```

```C#
Coalesce()
```

```C#
And()
```

```C#
Or()
```

```C#
Nor()
```

```C#
Max()
```

```C#
Min()
```

```C#
Avg()
```

```C#
Average()
```

```C#
Format()
```

```C#
Concat()
```

```C#
Join()
```

```C#
GetType(x)
```

```C#
ConvertType(x, y)
```

--------------------------------

### String Case Conversion

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Use ToUpper and ToLower to convert string case. Ensure the converter is correctly referenced as `StaticResource Math`.

```xaml
<TextBlock Text="{Binding Name,
    ConverterParameter='ToUpper(x)',
    Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Text="{Binding Name,
    ConverterParameter='ToLower(x)',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Logical and Null Handling Functions

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Functions for boolean logic and handling null values in bindings.

```APIDOC
## Logical and Null Handling

### Description
Enables conditional logic and null-coalescing behavior within XAML bindings.

### Functions
- **And(x, y)**: Logical AND operation.
- **Or(x, y)**: Logical OR operation.
- **IsNull(x, fallback)**: Returns fallback if x is null.
- **Coalesce(...args)**: Returns the first non-null value from the provided arguments.
```

--------------------------------

### String Concatenation with Concat

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Concatenate multiple strings with an optional separator. Use `MultiBinding` to provide multiple string sources.

```xaml
<TextBlock>
    <TextBlock.Text>
        <MultiBinding ConverterParameter="Concat(x, ` `, y)" Converter="{StaticResource Math}">
            <Binding Path="FirstName" />
            <Binding Path="LastName" />
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>
```

--------------------------------

### DateTime and Type Conversion

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Functions for working with dates, time arithmetic, and type casting.

```APIDOC
## DateTime and Type Conversion

### Description
Utilities for date manipulation, type parsing, and enum comparisons.

### Functions
- **Now()**: Returns current system time.
- **ConvertType(value, type)**: Converts a value to a specific type.
- **TryParseDouble(x)**: Attempts to parse a string to a double.
- **GetType(x)**: Returns type information for the object.
- **EnumEquals(x, enumValue)**: Compares an enum value against a string representation.
```

--------------------------------

### Define MathConverter Resource

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Register the MathConverter as an application resource for use in XAML.

```xml
<Application.Resources>
    <math:MathConverter x:Key="Math" />
</Application.Resources>
```

--------------------------------

### Display average calculation in XAML

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Displays the result of the Average function within a TextBlock.

```xaml
<TextBlock x:Name="TextBlock" Text="{Binding ConverterParameter='`Average(1, 1.5) returns ` + Average(1, 1.5)', Converter={StaticResource Math}}" />
```

--------------------------------

### Throw Exception for Debugging

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Intentionally throw an exception with provided arguments. This is primarily for debugging purposes to halt execution and inspect state.

```xaml
<TextBlock Text="{Binding Value,
    ConverterParameter='x > 0 ? x : Throw(`Invalid value`)',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Thickness and Multi-Value Types

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Specify multiple values separated by commas or semicolons for complex types like Thickness, CornerRadius, or Rect.

```xaml
<!-- Different horizontal/vertical margins -->
<Rectangle Margin="{Binding Spacing,
    ConverterParameter='0;x',
    Converter={StaticResource Math}}" />

<!-- Four different margin values -->
<Border Margin="{Binding Source={StaticResource Spacing},
    ConverterParameter='x;2x;x;2x',
    Converter={StaticResource Math}}" />

<!-- CornerRadius with different values per corner -->
<Border CornerRadius="{Binding Radius,
    ConverterParameter='x,0,x,0',
    Converter={StaticResource Math}}" />

<!-- No ConverterParameter: values joined with comma for type conversion -->
<Border>
    <Border.Margin>
        <MultiBinding Converter="{StaticResource Math}">
            <Binding Source="20" />
            <Binding Source="10" />
        </MultiBinding>
    </Border.Margin>
</Border>
```

--------------------------------

### Manage Custom Functions Programmatically

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Modify the CustomFunctions collection at runtime to add, remove, or replace functions and clear the expression cache.

```csharp
// Get MathConverter from resources
var math = (MathConverter)FindResource("Math");

// Add a custom function
math.CustomFunctions.Add(
    CustomFunctionDefinition.Create<MyCustomFunction>("MyFunc"));

// Remove a function by name
math.CustomFunctions.Remove("Average");

// Replace a built-in function with custom implementation
math.CustomFunctions.Remove("Average");
math.CustomFunctions.Add(
    CustomFunctionDefinition.Create<RoundedAverageFunction>("Average"));

// Clear all and re-register defaults
math.CustomFunctions.Clear();
math.CustomFunctions.RegisterDefaultFunctions();

// Clear the expression cache after modifying functions
math.ClearCache();

// Force binding to refresh
TextBlock.GetBindingExpression(TextBlock.TextProperty)?.UpdateTarget();
```

--------------------------------

### Built-in Functions

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

MathConverter provides a rich set of built-in functions for various operations. Functions are case-sensitive.

```APIDOC
## Built-in Functions

Functions are case-sensitive.

### General Functions
* `Now()`: Returns `System.DateTime.Now`.
* `UnsetValue()`: Returns `DependencyProperty.UnsetValue` or `BindableProperty.UnsetValue`.
* `DoNothing()`: Returns `Binding.DoNothing`.

### Mathematical Functions
* `Cos(x)`, `Sin(x)`, `Tan(x)`, `Abs(x)`: Behave like their `System.Math` counterparts.
* `Acos(x)`/`ArcCos(x)`, `Asin(x)`/`ArcSin(x)`, `Atan(x)`/`ArcTan(x)`: Inverse trigonometric functions.
* `Ceil(x)`/`Ceiling(x)`, `Floor(x)`: Rounding functions.
* `Sqrt(x)`: Square root.
* `Log(x, y)`: Logarithm.
* `Atan2(x, y)`/`ArcTan2(x, y)`: Arctangent of two numbers.
* `Round(x)`/`Round(x, y)`: Rounds a number.
* `Deg(x)`/`Degrees(x)`: Converts radians to degrees.
* `Rad(x)`/`Radians(x)`: Converts degrees to radians.

### String Manipulation Functions
* `ToLower(x)`/`LCase(x)`: Converts a string to lowercase.
* `ToUpper(x)`/`UCase(x)`: Converts a string to uppercase.
* `TryParseDouble(x)`: Attempts to convert `x` to a `double`.
* `StartsWith(x, y)`: Checks if a string starts with a specified prefix.
* `EndsWith(x, y)`: Checks if a string ends with a specified suffix.
* `Contains(x, y)`: Checks if a string or collection contains a specified value.

### Logical and Conditional Functions
* `IsNull()`/`IfNull()`/`Coalesce()`: Returns the first non-null argument.
* `And()`, `Or()`, `Nor()`: Perform logical operations on multiple arguments.
* `Max()`, `Min()`, `Avg()`/`Average()`: Return the maximum, minimum, or average of numeric values.

### Utility Functions
* `Format()`: Equivalent to `string.Format`.
* `Concat()`: Equivalent to `string.Concat`.
* `Join()`: Equivalent to `string.Join`.
* `GetType(x)`: Returns the type of `x`.
* `ConvertType(x, y)`: Attempts to convert `x` to type `y` using `InvariantCulture`.
```

--------------------------------

### Define Math Namespace

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Required XML namespace declaration for MathConverter.

```xml
xmlns:math="http://hexinnovation.com/math"
```

--------------------------------

### Joining Strings with a Separator

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Join a collection of strings into a single string using a specified separator. This is useful for creating comma-separated lists or similar.

```xaml
<TextBlock>
    <TextBlock.Text>
        <MultiBinding ConverterParameter="Join(`, `, x, y, z)" Converter="{StaticResource Math}">
            <Binding Path="Item1" />
            <Binding Path="Item2" />
            <Binding Path="Item3" />
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>
```

--------------------------------

### Register Custom Functions in XAML

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Add custom function definitions to the MathConverter's CustomFunctions collection within XAML resources.

```xaml
<Window.Resources>
    <math:MathConverter x:Key="Math">
        <!-- Register custom function with a name -->
        <math:CustomFunctionDefinition Name="GetWindowTitle"
            Function="local:GetWindowTitleFunction" />
        <math:CustomFunctionDefinition Name="DoubleIt"
            Function="local:DoubleValueFunction" />
    </math:MathConverter>
</Window.Resources>

<!-- Use custom function in binding -->
<ListBox.ItemTemplate>
    <DataTemplate DataType="sys:Type">
        <TextBlock Text="{Binding ConverterParameter='GetWindowTitle(x)',
            Converter={StaticResource Math}}" />
    </DataTemplate>
</ListBox.ItemTemplate>

<TextBlock Text="{Binding Value,
    ConverterParameter='DoubleIt(x)',
    Converter={StaticResource Math}}" />
```

--------------------------------

### DateTime Arithmetic and Formatting

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Perform arithmetic operations on `DateTime` and `TimeSpan` values. Use `ConvertType` to cast values and format the output.

```xaml
<TextBlock Text="{math:Convert '$`Six hours from now: {Now() + ConvertType(`6:00:00`, x):h\:mm tt}`',
    x={Binding Source={x:Type sys:TimeSpan}}}" />
```

--------------------------------

### Error Handling Functions

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Functions for managing exceptions and binding updates.

```APIDOC
## Error Handling

### Description
Provides mechanisms to handle errors gracefully or control binding updates.

### Functions
- **TryCatch(expression, fallback)**: Executes expression and returns fallback if an exception occurs.
- **Throw(message)**: Explicitly throws an exception.
- **DoNothing()**: Returns Binding.DoNothing to skip the update.
- **UnsetValue()**: Returns DependencyProperty.UnsetValue.
```

--------------------------------

### Implement custom function in C#

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Defines a custom function by extending OneArgFunction and overriding the Evaluate method.

```csharp
public class GetWindowTitleFunction : OneArgFunction
{
    public override object? Evaluate(CultureInfo cultureInfo, object? argument)
    {
        return argument is Type t && t.IsAssignableTo(typeof(Window)) ? ((Window)Activator.CreateInstance(t)!).Title : null;
    }
}
```

--------------------------------

### Type Conversion with TryParseDouble

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Attempt to parse a string into a double. Use the null-coalescing operator `??` to provide a default value if parsing fails.

```xaml
<TextBlock Text="{Binding StringValue,
    ConverterParameter='TryParseDouble(x) ?? 0',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Logical Operators in MathConverter

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Employ logical operators && (AND), || (OR), and ! (NOT) for boolean expressions in XAML bindings. Note that for '&&' and '||', multiple bindings may be required.

```xaml
<TextBlock Text="{Binding ConverterParameter='x && y ? `Both` : `Not both`', Converter={StaticResource Math}}">
    <MultiBinding>
        <Binding Path="A" />
        <Binding Path="B" />
    </MultiBinding>
</TextBlock>
```

--------------------------------

### MultiBinding with MathConverter

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Use MultiBinding to combine multiple values in a single expression. Access values using x, y, z for the first three bindings, or [0], [1], [2], etc. for any index.

```xaml
<!-- Calculate minimum of width and height divided by 2 -->
<Border>
    <Border.CornerRadius>
        <MultiBinding ConverterParameter="Min(x,y)/2" Converter="{StaticResource Math}">
            <Binding Path="ActualHeight" />
            <Binding Path="ActualWidth" />
        </MultiBinding>
    </Border.CornerRadius>
</Border>
```

```xaml
<!-- Using indexed access for more than 3 values -->
<TextBlock>
    <TextBlock.Text>
        <MultiBinding ConverterParameter="x + y + z + [3] + [4]" Converter="{StaticResource Math}">
            <Binding Path="Value1" />
            <Binding Path="Value2" />
            <Binding Path="Value3" />
            <Binding Path="Value4" />
            <Binding Path="Value5" />
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>
```

--------------------------------

### Interpolated Strings in XAML

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Use the $ prefix in ConverterParameter to format strings with embedded expressions and format specifiers.

```xaml
<!-- Pluralization with interpolated strings -->
<TextBlock Text="{Binding NumClicks,
    ConverterParameter='$`You have clicked the button {x} time{(x == 1 ? `` : `s`)}.`',
    Converter={StaticResource Math}}" />

<!-- Number formatting -->
<TextBlock Text="{Binding Price,
    ConverterParameter='$`Total: {x:C2}`',
    Converter={StaticResource Math}}" />

<!-- Percentage formatting -->
<TextBlock Text="{Binding Progress,
    ConverterParameter='$`Progress: {x:P0} complete`',
    Converter={StaticResource Math}}" />

<!-- Multiple values in interpolated string -->
<TextBlock>
    <TextBlock.Text>
        <MultiBinding ConverterParameter="$`Coordinates: ({x:N2}, {y:N2})`"
            Converter="{StaticResource Math}">
            <Binding Path="X" />
            <Binding Path="Y" />
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>
```

--------------------------------

### Math Functions in XAML

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Apply built-in math functions like trigonometry, rounding, and min/max within the ConverterParameter. Function names are case-sensitive.

```xaml
<!-- Trigonometry functions -->
<RotateTransform Angle="{Binding Radians,
    ConverterParameter='Degrees(x)',
    Converter={StaticResource Math}}" />

<TextBlock Text="{Binding Angle,
    ConverterParameter='Sin(Radians(x))',
    Converter={StaticResource Math}}" />

<!-- Rounding functions -->
<TextBlock Text="{Binding Value,
    ConverterParameter='Round(x, 2)',
    Converter={StaticResource Math}}" />

<TextBlock Text="{Binding Value,
    ConverterParameter='Ceiling(x)',
    Converter={StaticResource Math}}" />

<TextBlock Text="{Binding Value,
    ConverterParameter='Floor(x)',
    Converter={StaticResource Math}}" />

<!-- Min, Max, Average with multiple arguments -->
<TextBlock>
    <TextBlock.Text>
        <MultiBinding ConverterParameter="Max(x, y, z)" Converter="{StaticResource Math}">
            <Binding Path="Value1" />
            <Binding Path="Value2" />
            <Binding Path="Value3" />
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>

<!-- Absolute value and square root -->
<TextBlock Text="{Binding Delta,
    ConverterParameter='Abs(x)',
    Converter={StaticResource Math}}" />

<TextBlock Text="{Binding Area,
    ConverterParameter='Sqrt(x)',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Constants in MathConverter

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

MathConverter supports mathematical constants like 'e' (Euler's number) and 'pi', as well as boolean constants 'true' and 'false', and 'null'. These can be used directly in expressions.

```xaml
<TextBlock Text="{Binding Radius, ConverterParameter='2 * pi * x', Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Text="{Binding X, ConverterParameter='e ^ x', Converter={StaticResource Math}}" />
```

--------------------------------

### Register custom function in Resources

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Registers a custom function definition within the MathConverter resource.

```xaml
<Window.Resources>
    <math:MathConverter x:Key="Math">
        <!-- "GetWindowTitle" in the parameter will invoke the `GetWindowTitleFunction` function. -->
        <math:CustomFunctionDefinition Name="GetWindowTitle" Function="local:GetWindowTitleFunction" />
    </math:MathConverter>
</Window.Resources>
```

--------------------------------

### Implicit Multiplication in MathConverter

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

MathConverter supports implicit multiplication, allowing expressions like '2x' or 'x2y'. This can also be used with parentheses, such as '2(x+1)'.

```xaml
<TextBlock Text="{Binding X, ConverterParameter='2x', Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Text="{Binding X, ConverterParameter='x2y', Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Text="{Binding X, ConverterParameter='2(x+1)', Converter={StaticResource Math}}" />
```

--------------------------------

### Comparison Operators in MathConverter

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Utilize comparison operators such as ==, !=, <, >, <=, and >= within XAML bindings for conditional logic. These are often used with the ternary operator.

```xaml
<TextBlock Visibility="{Binding X, ConverterParameter='x > 0 ? `Visible` : `Collapsed`', Converter={StaticResource Math}}" />
```

```xaml
<TextBlock Visibility="{Binding X, ConverterParameter='x == 0 ? `Visible` : `Collapsed`', Converter={StaticResource Math}}" />
```

--------------------------------

### Coalesce with Multiple Fallbacks

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Chain multiple fallback values for null coalescing. The function returns the first non-null value from the provided arguments.

```xaml
<TextBlock>
    <TextBlock.Text>
        <MultiBinding ConverterParameter="Coalesce(x, y, z, `Default`)" Converter="{StaticResource Math}">
            <Binding Path="PreferredName" />
            <Binding Path="FirstName" />
            <Binding Path="Username" />
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>
```

--------------------------------

### Boolean to Visibility Conversion with MathConverter

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Convert boolean values to Visibility enum values using ternary expressions. Strings in expressions can use backticks, single quotes, or double quotes.

```xaml
<!-- Show/hide element based on boolean -->
<TextBox Visibility="{Binding IsChecked, ElementName=CheckBox,
    ConverterParameter='x ? `Visible` : `Collapsed`',
    Converter={StaticResource Math}}" />
```

```xaml
<!-- Using Hidden instead of Collapsed -->
<Border Visibility="{Binding ShowBorder,
    ConverterParameter='x ? `Visible` : `Hidden`',
    Converter={StaticResource Math}}" />
```

```xaml
<!-- Inverse visibility -->
<TextBlock Visibility="{Binding IsLoading,
    ConverterParameter='!x ? `Visible` : `Collapsed`',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Perform time calculations in XAML

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Uses ConvertType to convert a string to TimeSpan and adds it to the current time.

```xaml
<TextBlock Text="{math:Convert '$`Six hours from now, the time will be {Now() + ConvertType(`6:00:00`, x):h\':\'mm\':\'ss tt}\nWe bind to a property that updates every second, in order to update the string.`', x={Binding Source={x:Type sys:TimeSpan}}, y={Binding OneSecondTimer, RelativeSource={RelativeSource AncestorType=Window}}}" />
```

--------------------------------

### Logical AND/OR Operations

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Perform logical AND and OR operations on boolean values. The result can control UI element properties like `IsEnabled` or `Visibility`.

```xaml
<Button IsEnabled="{Binding ConverterParameter='And(x, y)', Converter={StaticResource Math}}">
    <MultiBinding>
        <Binding Path="IsValid" />
        <Binding Path="IsEnabled" />
    </MultiBinding>
</Button>
```

```xaml
<TextBlock Visibility="{Binding ConverterParameter='Or(x, y) ? `Visible` : `Collapsed`', Converter={StaticResource Math}}">
    <MultiBinding>
        <Binding Path="ShowAlways" />
        <Binding Path="HasContent" />
    </MultiBinding>
</TextBlock>
```

--------------------------------

### Enum Comparison

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Compare an enum value against a string representation of an enum member. Returns a boolean result for conditional logic.

```xaml
<Border Background="{Binding Status,
    ConverterParameter='EnumEquals(x, `Active`) ? `Green` : `Gray`',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Replace VisibleOrHidden function

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Use a ternary expression to replicate the functionality of the removed VisibleOrHidden function.

```text
x ? `Visible` : `Hidden`
```

--------------------------------

### Interpolated Strings in MathConverter

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

MathConverter supports interpolated strings within the ConverterParameter for dynamic string formatting, similar to C#.

```xaml

```

--------------------------------

### Apply custom function in DataTemplate

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Uses a custom function within a DataTemplate to convert Type objects to display values.

```xaml
<ListBox.ItemTemplate>
    <DataTemplate DataType="sys:Type">
        <TextBlock Text="{Binding ConverterParameter='GetWindowTitle(x)', Converter={StaticResource Math}}" />
    </DataTemplate>
</ListBox.ItemTemplate>
```

--------------------------------

### Null Coalescing with IsNull

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Provide a fallback value when a binding is null. The `x` parameter is the value to check, and the second parameter is the fallback.

```xaml
<TextBlock Text="{Binding DisplayName,
    ConverterParameter='IsNull(x, `Unknown`)',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Disabling MathConverter Cache

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

This XAML snippet shows how to disable the caching mechanism for a MathConverter instance. Set UseCache to "False" when you want to prevent MathConverter from storing parsed AbstractSyntaxTrees, which can be useful for managing memory, especially when using a single MathConverter instance across a large application.

```xaml
<math:MathConverter x:Key="nocache" UseCache="False" />
```

--------------------------------

### Convert Boolean to Visibility with MathConverter

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Use the ternary operator within ConverterParameter to convert a boolean binding to a Visibility value. Strings within the parameter can be delimited by double quotes, single quotes, or grave accents.

```xaml
<TextBox Visibility="{Binding IsChecked, ElementName=CheckBox, ConverterParameter='x ? `Visible` : `Collapsed`', Converter={StaticResource Math}}" />
```

--------------------------------

### Skip Update with DoNothing

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Return `Binding.DoNothing` to prevent the binding target from being updated. This is useful when a condition is met that should not trigger a UI change.

```xaml
<TextBlock Text="{Binding Value,
    ConverterParameter='x > 0 ? x : DoNothing()',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Null Coalescing Operator in MathConverter

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Use the null coalescing operator (??) to provide a default value when a binding source is null. This is useful for handling potentially missing data.

```xaml
<TextBlock Text="{Binding Name, ConverterParameter='x ?? `Unknown`', Converter={StaticResource Math}}" />
```

--------------------------------

### Return UnsetValue

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

Return `DependencyProperty.UnsetValue` to indicate that the binding value is not available or should not be applied. This can reset the property to its default value.

```xaml
<TextBlock Text="{Binding Value,
    ConverterParameter='x != null ? x : UnsetValue()',
    Converter={StaticResource Math}}" />
```

--------------------------------

### Replace VisibleOrCollapsed function

Source: https://github.com/hexinnovation/mathconverter/blob/main/README.md

Use a ternary expression to replicate the functionality of the removed VisibleOrCollapsed function.

```text
x ? `Visible` : `Collapsed`
```

--------------------------------

### Ternary Operator in MathConverter

Source: https://context7.com/hexinnovation/mathconverter/llms.txt

The ternary operator (condition ? value_if_true : value_if_false) is supported for concise conditional assignments within XAML bindings. Nested ternary operators are also allowed.

```xaml
<TextBlock Text="{Binding X, ConverterParameter='x > 100 ? `Large` : (x > 50 ? `Medium` : `Small`)', Converter={StaticResource Math}}" />
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.