Math expression markup extension

[tkefauver]

This extension lets you bind double or bool type properties to a parameterized equation which has proven pretty handy so I thought I'd share it :)

It allows binding to 4 variables a,b,c,d (arbitrarily 4 and assumes they're all doubles). Then you provide an exp string that uses those variable names to evaluate the result which can be a double or bool (when you set IsBoolResult=true).

Random examples:
A variable FontSize based on a dimension of some control:

FontSize="{local:MathBinding a={Binding $parent[Grid].Bounds.Width}, exp=(a/3)+1}"

Conditionally hiding a view when something is too big let's say which needs a bool result. This requires the exp to use an IF(exp,true val,false val) syntax (or anything MathEval supports):

IsVisible="{local:MathBinding a={Binding Bounds.Width,ElementName=SomeElement}, b={Binding Bounds.Width,ElementName=SomeOtherElement}, IsBoolResult=true, exp=IF(a-b<0,1,0)}"

Notes:
When bound variables aren't defined/imaginary(yet) it just defaults them to 0 but you could change that behavior.

Also to avoid divide by zero issues its a good idea to add a small number to any divisor variables like exp=a/(b+0.001)

To use it you need to add MathEval:
dotnet add package org.matheval

Code:

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Avalonia.Data;
using Avalonia.Data.Converters;
using org.matheval;

namespace Example {
    public class MathBinding {
        public BindingBase a { get; set; }
        public BindingBase b { get; set; }
        public BindingBase c { get; set; }
        public BindingBase d { get; set; }
        public bool IsBoolResult { get; set; }
        public string exp { get; set; }

        public object ProvideValue() {
            MultiBinding mb = new MultiBinding
            {
                Bindings = new[] { a,b,c,d }.Where(x => x != null).Cast<IBinding>().ToList(),
                Converter = new MathMultiValueConverter(exp,IsBoolResult),
            };

            return mb;
        }

        internal class MathMultiValueConverter : IMultiValueConverter {
            static readonly string[] VariableNames = ["a","b","c","d"];
            Expression Exp { get; }
            bool IsBoolResult { get; }

            internal MathMultiValueConverter(string exp,bool isBoolResult) {
                Exp = new Expression(exp);
                IsBoolResult = isBoolResult;
            }

            public object Convert(IList<object> values,Type targetType,object parameter,CultureInfo culture) {
                for(int i = 0; i < values.Count; i++) {
                    if(values[i] == null ||
                       !double.TryParse(values[i].ToString(),out double dbl_val) ||
                       double.IsNaN(dbl_val) ||
                       double.IsPositiveInfinity(dbl_val) ||
                       double.IsNegativeInfinity(dbl_val)) {
                        // when variable unset, undefined, NAN etc. default to 0
                        dbl_val = 0;
                    }

                    Exp.Bind(VariableNames[i],dbl_val);
                }

                if(Exp.GetError().Count > 0) {
                    // handle error (dumps variables)
                    var variables = Exp.getVariables();
                    foreach(string variable in variables) {
                        Console.WriteLine(variable); // will print x, a
                    }

                    return IsBoolResult ? false : 0;
                }


                double result = Exp.Eval<double>();
                if(IsBoolResult) {
                    // example:
                    // exp: IF(a+5<b,1,0)
                    // ie: IF(cond,true val,false val)
                    return (int)result == 1;
                }

                return result;
            }
        }
    }
}