Arithmetic expression functions

src/Altinn.App.Core/Internal/Expressions/ExpressionEvaluator.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using System.Numerics;
 using System.Text.Json;
 using System.Text.RegularExpressions;
 using Altinn.App.Core.Models;
@@ -11,7 +12,7 @@ namespace Altinn.App.Core.Internal.Expressions;
 /// <summary>
 /// Static class used to evaluate expressions. Holds the implementation for all expression functions.
 /// </summary>
-public static class ExpressionEvaluator
+public static partial class ExpressionEvaluator
 {
     /// <summary>
     /// Shortcut for evaluating a boolean expression on a given property on a <see cref="Models.Layout.Components.Base.BaseComponent" />
@@ -127,6 +128,10 @@ internal static async Task<ExpressionValue> EvaluateExpression_internal(
             ExpressionFunction.argv => Argv(args, positionalArguments),
             ExpressionFunction.gatewayAction => state.GetGatewayAction(),
             ExpressionFunction.language => state.GetLanguage(),
+            ExpressionFunction.plus => Plus(args),
+            ExpressionFunction.minus => Minus(args),
+            ExpressionFunction.multiply => Multiply(args),
+            ExpressionFunction.divide => Divide(args),
             ExpressionFunction.INVALID => throw new ExpressionEvaluatorTypeErrorException(
                 $"Function {expr.Args.FirstOrDefault()} not implemented in backend {expr}"
             ),
@@ -610,8 +615,8 @@ private static int StringLength(ExpressionValue[] args)
             throw new ExpressionEvaluatorTypeErrorException($"Expected 2-3 arguments, got {args.Length}");
         }
         string? subject = args[0].ToStringForEquals();
-        double? start = PrepareNumericArg(args[1]);
-        double? end = args.Length == 3 ? PrepareNumericArg(args[2]) : null;
+        double? start = PrepareNumericArg<double>(args[1]);
+        double? end = args.Length == 3 ? PrepareNumericArg<double>(args[2]) : null;
         bool hasEnd = args.Length == 3;
 
         if (start == null || (hasEnd && end == null))
@@ -659,13 +664,13 @@ private static string Round(ExpressionValue[] args)
             );
         }
 
-        var number = PrepareNumericArg(args[0]) ?? 0;
+        var number = PrepareNumericArg<double>(args[0]) ?? 0;
 
         int precision = 0;
 
         if (args.Length == 2)
         {
-            precision = (int)(PrepareNumericArg(args[1]) ?? 0);
+            precision = (int)(PrepareNumericArg<double>(args[1]) ?? 0);
         }
 
         return number.ToString($"N{precision}", CultureInfo.InvariantCulture);
@@ -806,33 +811,51 @@ ExpressionValue[] args
         return !PrepareBooleanArg(args[0]);
     }
 
-    private static (double?, double?) PrepareNumericArgs(ExpressionValue[] args)
+    private static (T?, T?) PrepareNumericArgs<T>(ExpressionValue[] args)
+        where T : struct, INumber<T>
     {
         if (args.Length != 2)
         {
-            throw new ExpressionEvaluatorTypeErrorException("Invalid number of args for compare");
+            throw new ExpressionEvaluatorTypeErrorException("Invalid number of args");
         }
 
-        var a = PrepareNumericArg(args[0]);
+        var a = PrepareNumericArg<T>(args[0]);
 
-        var b = PrepareNumericArg(args[1]);
+        var b = PrepareNumericArg<T>(args[1]);
 
         return (a, b);
     }
 
-    private static double? PrepareNumericArg(ExpressionValue arg)
+    private static T? PrepareNumericArg<T>(ExpressionValue arg)
+        where T : struct, INumber<T>
     {
         return arg.ValueKind switch
         {
             JsonValueKind.True or JsonValueKind.False or JsonValueKind.Array or JsonValueKind.Object =>
                 throw new ExpressionEvaluatorTypeErrorException($"Expected number, got value {arg}"),
-            JsonValueKind.String => ParseNumber(arg.String, throwException: true),
-            JsonValueKind.Number => arg.Number,
+            JsonValueKind.String => ParseNumber<T>(arg.String, throwException: true),
+            JsonValueKind.Number => CastNumber<T>(arg.Number),
 
             _ => null,
         };
     }
 
+    private static T? CastNumber<T>(double? number)
+        where T : struct, INumber<T>
+    {
+        if (typeof(T) != typeof(decimal))
+        {
+            return number.HasValue ? T.CreateChecked(number.Value) : null;
+        }
+
+        if (number.HasValue && ValidFloatingPoint(number.Value))
+        {
+            return T.CreateChecked(number.Value);
+        }
+
+        return null;
+    }
+
     private static ExpressionValue IfImpl(ExpressionValue[] args)
     {
         if (args.Length == 2)
@@ -861,11 +884,13 @@ private static ExpressionValue IfImpl(ExpressionValue[] args)
         );
     }
 
-    private static readonly Regex _numberRegex = new Regex(@"^-?\d+(\.\d+)?$");
-
-    internal static double? ParseNumber(string s, bool throwException = true)
+    /// <summary>
+    /// Parses a number from a string representation.
+    /// </summary>
+    internal static T? ParseNumber<T>(string s, bool throwException = true)
+        where T : struct, INumber<T>
     {
-        if (_numberRegex.IsMatch(s) && double.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var d))
+        if (NumberRegex().IsMatch(s) && T.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var d))
         {
             return d;
         }
@@ -879,7 +904,7 @@ private static ExpressionValue IfImpl(ExpressionValue[] args)
 
     private static bool LessThan(ExpressionValue[] args)
     {
-        var (a, b) = PrepareNumericArgs(args);
+        var (a, b) = PrepareNumericArgs<double>(args);
 
         if (a is null || b is null)
         {
@@ -888,9 +913,37 @@ private static bool LessThan(ExpressionValue[] args)
         return a < b; // Actual implementation
     }
 
+    private static double? Plus(ExpressionValue[] args)
+    {
+        var (a, b) = PrepareNumericArgs<decimal>(args);
+        return PerformArithmetic(a, b, (x, y) => x + y);
+    }
+
+    private static double? Minus(ExpressionValue[] args)
+    {
+        var (a, b) = PrepareNumericArgs<decimal>(args);
+        return PerformArithmetic(a, b, (x, y) => x - y);
+    }
+
+    private static double? Multiply(ExpressionValue[] args)
+    {
+        var (a, b) = PrepareNumericArgs<decimal>(args);
+        return PerformArithmetic(a, b, (x, y) => x * y);
+    }
+
+    private static double? Divide(ExpressionValue[] args)
+    {
+        var (a, b) = PrepareNumericArgs<decimal>(args);
+        if (a != null && b == 0)
+        {
+            throw new ExpressionEvaluatorTypeErrorException("The second argument is 0, cannot divide by 0");
+        }
+        return PerformArithmetic(a, b, (x, y) => x / y);
+    }
+
     private static bool LessThanEq(ExpressionValue[] args)
     {
-        var (a, b) = PrepareNumericArgs(args);
+        var (a, b) = PrepareNumericArgs<double>(args);
 
         if (a is null || b is null)
         {
@@ -901,7 +954,7 @@ private static bool LessThanEq(ExpressionValue[] args)
 
     private static bool GreaterThan(ExpressionValue[] args)
     {
-        var (a, b) = PrepareNumericArgs(args);
+        var (a, b) = PrepareNumericArgs<double>(args);
 
         if (a is null || b is null)
         {
@@ -912,7 +965,7 @@ private static bool GreaterThan(ExpressionValue[] args)
 
     private static bool GreaterThanEq(ExpressionValue[] args)
     {
-        var (a, b) = PrepareNumericArgs(args);
+        var (a, b) = PrepareNumericArgs<double>(args);
 
         if (a is null || b is null)
         {
@@ -943,7 +996,7 @@ private static ExpressionValue Argv(ExpressionValue[] args, ExpressionValue[]? p
             throw new ExpressionEvaluatorTypeErrorException($"Expected 1 argument(s), got {args.Length}");
         }
 
-        var index = (int?)PrepareNumericArg(args[0]);
+        var index = (int?)PrepareNumericArg<double>(args[0]);
         if (!index.HasValue)
         {
             throw new ExpressionEvaluatorTypeErrorException($"Expected number, got value \"{args[0]}\"");
@@ -960,4 +1013,47 @@ private static ExpressionValue Argv(ExpressionValue[] args, ExpressionValue[]? p
 
         return positionalArguments[index.Value];
     }
+
+    /// <summary>
+    /// Performs arithmetic operation using decimal precision to avoid floating point precision issues.
+    /// Converts doubles to decimal, performs the operation, and converts back to double.
+    /// </summary>
+    /// <param name="aDecimal">First operand</param>
+    /// <param name="bDecimal">Second operand</param>
+    /// <param name="operation">Function that performs the arithmetic operation on two decimals</param>
+    /// <returns>Result of the operation as double, or null if any operand is null</returns>
+    private static double? PerformArithmetic(
+        decimal? aDecimal,
+        decimal? bDecimal,
+        Func<decimal, decimal, decimal> operation
+    )
+    {
+        if (aDecimal.HasValue is false || bDecimal.HasValue is false)
+        {
+            return null;
+        }
+
+        var result = operation(aDecimal.Value, bDecimal.Value);
+
+        return (double)result;
+    }
+
+    private static bool ValidFloatingPoint(double value)
+    {
+        if (
+            double.IsNaN(value)
+            || double.IsInfinity(value)
+            || value > (double)decimal.MaxValue
+            || value < (double)decimal.MinValue
+        )
+        {
+            throw new ExpressionEvaluatorTypeErrorException(
+                $"Cannot convert non-finite or out-of-range number to decimal: {value}"
+            );
+        }
+        return true;
+    }
+
+    [GeneratedRegex(@"^-?\d+(\.\d+)?$")]
+    private static partial Regex NumberRegex();
 }

src/Altinn.App.Core/Internal/Expressions/ExpressionValue.cs

@@ -141,9 +141,7 @@ public static ExpressionValue FromObject(object? value)
             uint numberValue => numberValue,
             long numberValue => numberValue,
             ulong numberValue => numberValue,
-            decimal numberValue =>
-                (double?)numberValue // expressions uses double which needs an explicit cast
-            ,
+            decimal numberValue => (double?)numberValue, // expressions uses double which needs an explicit cast
             DateTime dateTimeValue => JsonSerializer
                 .Serialize(dateTimeValue, _unsafeSerializerOptionsForSerializingDates)
                 .Trim(
@@ -422,7 +420,7 @@ public override int GetHashCode()
                 "0" => false,
                 { } sValue when sValue.Equals("true", StringComparison.OrdinalIgnoreCase) => true,
                 { } sValue when sValue.Equals("false", StringComparison.OrdinalIgnoreCase) => false,
-                _ => ExpressionEvaluator.ParseNumber(String, throwException: false) switch
+                _ => ExpressionEvaluator.ParseNumber<double>(String, throwException: false) switch
                 {
                     1 => true,
                     0 => false,
@@ -525,7 +523,7 @@ public bool TryDeserialize(Type type, out object? result)
             // Support parsing numbers from strings for numeric types
             case JsonValueKind.String when IsSupportedNumericType(underlyingType):
             {
-                var parsedNumber = ExpressionEvaluator.ParseNumber(String, throwException: false);
+                var parsedNumber = ExpressionEvaluator.ParseNumber<double>(String, throwException: false);
                 if (parsedNumber.HasValue)
                 {
                     result = Convert.ChangeType(parsedNumber.Value, underlyingType, CultureInfo.InvariantCulture);
@@ -560,7 +558,7 @@ public bool TryDeserialize(Type type, out object? result)
         try
         {
             var json = ToString();
-            result = JsonSerializer.Deserialize(json, type, _unsafeSerializerOptionsForSerializingDates);
+            result = JsonSerializer.Deserialize(json, type);
             return true;
         }
         catch (JsonException)

src/Altinn.App.Core/Models/Expressions/ExpressionFunction.cs

@@ -205,4 +205,24 @@ public enum ExpressionFunction
     /// If no translations exist for the current language, we will use the resources for "nb"
     /// </summary>
     text,
+
+    /// <summary>
+    /// Adding numbers. Use a period (.) as the decimals separator. Must be numeric values.
+    /// </summary>
+    plus,
+
+    /// <summary>
+    /// Subtracting all preceding values from the first. Use a period (.) as the decimals separator. Must be numeric values.
+    /// </summary>
+    minus,
+
+    /// <summary>
+    /// Multiplying numbers. Use a period (.) as the decimals separator. Must be numeric values.
+    /// </summary>
+    multiply,
+
+    /// <summary>
+    /// Divide numbers. Use a period (.) as the decimals separator. Must be numeric values.
+    /// </summary>
+    divide,
 }

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ExpressionTestCaseRoot.cs

@@ -10,6 +10,16 @@ namespace Altinn.App.Core.Tests.LayoutExpressions.CommonTests;
 
 public class ExpressionTestCaseRoot
 {
+    public ExpressionTestCaseRoot(TestCaseItem testCaseItem)
+    {
+        Name = testCaseItem.Name;
+        Expression = testCaseItem.Expression;
+        Expects = testCaseItem.Expects;
+        ExpectsFailure = testCaseItem.ExpectsFailure;
+    }
+
+    public ExpressionTestCaseRoot() { }
+
     [JsonIgnore]
     public string? Filename { get; set; }
 
@@ -42,6 +52,9 @@ public class ExpressionTestCaseRoot
 
     public class TestCaseItem
     {
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+
         [JsonPropertyName("expression")]
         public required Expression Expression { get; set; }
 

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/TestBackendExclusiveFunctions.cs

@@ -1,5 +1,6 @@
 using System.Text.Json;
 using Altinn.App.Core.Internal.Expressions;
+using Altinn.App.Core.Models.Expressions;
 using Altinn.App.Core.Models.Layout;
 using Altinn.App.Core.Tests.LayoutExpressions.TestUtilities;
 using Altinn.App.Core.Tests.TestUtils;