How to create a formatter for math calculations

[Begounet]

Hi!

I am currently struggling doing chained combined formatters and I wanted to know if it was even possible from the beginning.

Admitting I create custom formatters "add" and "mul", respectively adding a value to a source and multiplying a value with the source.
So, writing something like this:
{0:add(3):mul(10)} with {0} being 5, will output 80 (because (5+3)*10).
Here the result is of {0:add(3) becomes the source (as a numeric value) of :mul(10).

Is that something possible to do? If that's the case, how can I modify my custom formatters to make it work?

In my own use case, I wanted to convert a ratio value to a rounded percent value by doing {0:mul(100):round(to_int)} (round is also a custom formatter) but no success...

Thank you for any help you could provide me!

[axunonb]

Yes, generally this can be done. However, by default formatting proceeds from left to right.
Before explaining a lot, here is a proof of concept in code.
(Btw: Putting the calculation method into the option part might reduce the number of required custom formatters.)

/// <summary>
/// A simplistic math formatter
/// </summary>
public class SimplisticMathFormatter : IFormatter
{
    /// <inheritdoc/>
    public string Name { get; set; } = "math";

    /// <inheritdoc/>
    public bool CanAutoDetect { get; set; } = false;

    /// <inheritdoc/>
    public bool TryEvaluateFormat(IFormattingInfo formattingInfo)
    {
        // + - * /
        var calculationType = formattingInfo.FormatterOptions;

        // back-reference the parent FormattingInfo
        var parentValue = ((Core.Formatting.FormattingInfo) formattingInfo).Parent!;

        var childFormatter = Smart.CreateDefaultSmartFormat();
        childFormatter.AddExtensions(new SimplisticMathFormatter());

        var arg1Value = (int) Convert.ChangeType(formattingInfo.CurrentValue, TypeCode.Int32);
        var arg2Value = int.Parse(childFormatter.Format(formattingInfo.Format!, parentValue.CurrentValue));

        switch (calculationType)
        {
            case "+":
                formattingInfo.Write((arg1Value + arg2Value).ToString());
                break;
            case "-":
                formattingInfo.Write((arg1Value - arg2Value).ToString());
                break;
            case "*":
                formattingInfo.Write((arg1Value * arg2Value).ToString());
                break;
            case "/":
                formattingInfo.Write((arg1Value / arg2Value).ToString());
                break;
        }

        return true;
    }
}

Here are the corresponding unit tests:

[TestFixture]
public class SimplisticMathFormatterTests
{
    [TestCase(5, 2, "+", "7")]
    [TestCase(20, 15, "-", "5")]
    [TestCase(4, 5, "*", "20")]
    [TestCase(10, 5, "/", "2")]
    public void CalculationTypeTests(int arg1, int arg2, string calcType, string expected)
    {
        var smart = Smart.CreateDefaultSmartFormat();
        smart.AddExtensions(new SimplisticMathFormatter());

        var data = new { Arg1 = arg1, Arg2 = arg2};

        // calcType must be a literal
        var result = smart.Format("{Arg1:math(" + calcType + "):{Arg2}}", data);

        Assert.That(result, Is.EqualTo(expected));
    }

    [TestCase(5, 2, 10, "+", "*", "70")]
    [TestCase(20, 15, 10, "-", "*", "50")]
    [TestCase(4, 5, 10, "*", "*", "200")]
    [TestCase(10, 5, 10, "/", "*", "20")]
    public void NestedCalculationTests(int arg1, int arg2, int arg3, string calcType1, string calcType2, string expected)
    {
        var smart = Smart.CreateDefaultSmartFormat();
        smart.AddExtensions(new SimplisticMathFormatter());

        var data = new { Arg1 = arg1, Arg2 = arg2, Arg3 = 10};

        // calcType1 / calcType2 must be literals
        var result = smart.Format("{Arg3:math(" + calcType2 + "):{Arg1:math(" + calcType1 + "):{Arg2}}}", data);

        Assert.That(result, Is.EqualTo(expected));
    }
}

After all: This is feasible, but for more advanced scenarios a formatter extension using a math parser like NCalc or MathParser would be better.

[axunonb]

@Begounet Which way did you go with this?

[Begounet]

Thanks for your answer (and sorry for delay, was in vacation)!

I went on creating a special "percent" formatter to do exactly what I wanted while I was waiting for an answer.

I would still prefer the idea to make the combination than creating another formatter. However, even if your solution is interesting (and I thank you again to take the time to answer/write it), I am not going for it because:

• the backtracking solution is not intuitive for anyone reading the format,
• it may be a difference on Unity side but I formattingInfo.Format (in childFormatter.Format() call) returns me only the remaining literal expression (in {0:mul(100):round(toint)}, it returns round(toint), not something like {0:round(toint)} so the smart.Format does nothing). I did not manage to get {0:round(toint)} from the formatting info (not without remaking everything myself, I mean).
• every formatter should add this kind of "parenting evaluation" to support chaining

[axunonb]

Ah, welcome back :) and thanks for the comments.
The draft of this kind of "Logic and Calculation Formatter" may still be interesting. Open for discussion / evaluation.

[axunonb]

Put your request to the wish list (see #299)