Arithmetic expression functions

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

@@ -127,6 +127,11 @@ internal static async Task<ExpressionValue> EvaluateExpression_internal(
             ExpressionFunction.argv => Argv(args, positionalArguments),
             ExpressionFunction.gatewayAction => state.GetGatewayAction(),
             ExpressionFunction.language => state.GetLanguage(),
+            // Calculations:
+            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;
+        decimal? start = PrepareNumericArg(args[1]);
+        decimal? end = args.Length == 3 ? PrepareNumericArg(args[2]) : null;
         bool hasEnd = args.Length == 3;
 
         if (start == null || (hasEnd && end == null))
@@ -806,7 +811,7 @@ ExpressionValue[] args
         return !PrepareBooleanArg(args[0]);
     }
 
-    private static (double?, double?) PrepareNumericArgs(ExpressionValue[] args)
+    private static (decimal?, decimal?) PrepareTwoNumericArgs(ExpressionValue[] args)
     {
         if (args.Length != 2)
         {
@@ -820,7 +825,7 @@ private static (double?, double?) PrepareNumericArgs(ExpressionValue[] args)
         return (a, b);
     }
 
-    private static double? PrepareNumericArg(ExpressionValue arg)
+    private static decimal? PrepareNumericArg(ExpressionValue arg)
     {
         return arg.ValueKind switch
         {
@@ -861,11 +866,11 @@ private static ExpressionValue IfImpl(ExpressionValue[] args)
         );
     }
 
-    private static readonly Regex _numberRegex = new Regex(@"^-?\d+(\.\d+)?$");
+    private static readonly Regex _numberRegex = new(@"^-?\d+(\.\d+)?$");
 
-    internal static double? ParseNumber(string s, bool throwException = true)
+    internal static decimal? ParseNumber(string s, bool throwException = true)
     {
-        if (_numberRegex.IsMatch(s) && double.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var d))
+        if (_numberRegex.IsMatch(s) && decimal.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var d))
         {
             return d;
         }
@@ -879,7 +884,7 @@ private static ExpressionValue IfImpl(ExpressionValue[] args)
 
     private static bool LessThan(ExpressionValue[] args)
     {
-        var (a, b) = PrepareNumericArgs(args);
+        var (a, b) = PrepareTwoNumericArgs(args);
 
         if (a is null || b is null)
         {
@@ -888,9 +893,49 @@ private static bool LessThan(ExpressionValue[] args)
         return a < b; // Actual implementation
     }
 
+    private static decimal? Plus(ExpressionValue[] args)
+    {
+        var (a, b) = PrepareTwoNumericArgs(args);
+        return a + b;
+    }
+
+    private static decimal? Minus(ExpressionValue[] args)
+    {
+        if (args.Length == 0)
+        {
+            return 0;
+        }
+        var (a, b) = PrepareTwoNumericArgs(args);
+        return a - b;
+    }
+
+    private static decimal? Multiply(ExpressionValue[] args)
+    {
+        if (args.Length <= 1)
+        {
+            throw new ExpressionEvaluatorTypeErrorException("Two arguments must be provided");
+        }
+        var (a, b) = PrepareTwoNumericArgs(args);
+        return a * b;
+    }
+
+    private static decimal? Divide(ExpressionValue[] args)
+    {
+        if (args.Length <= 1)
+        {
+            throw new ExpressionEvaluatorTypeErrorException("At least two arguments must be provided");
+        }
+        var (a, b) = PrepareTwoNumericArgs(args);
+        if (b == 0)
+        {
+            throw new ExpressionEvaluatorTypeErrorException("Argument two is 0, cannot divide by 0");
+        }
+        return a / b;
+    }
+
     private static bool LessThanEq(ExpressionValue[] args)
     {
-        var (a, b) = PrepareNumericArgs(args);
+        var (a, b) = PrepareTwoNumericArgs(args);
 
         if (a is null || b is null)
         {
@@ -901,7 +946,7 @@ private static bool LessThanEq(ExpressionValue[] args)
 
     private static bool GreaterThan(ExpressionValue[] args)
     {
-        var (a, b) = PrepareNumericArgs(args);
+        var (a, b) = PrepareTwoNumericArgs(args);
 
         if (a is null || b is null)
         {
@@ -912,7 +957,7 @@ private static bool GreaterThan(ExpressionValue[] args)
 
     private static bool GreaterThanEq(ExpressionValue[] args)
     {
-        var (a, b) = PrepareNumericArgs(args);
+        var (a, b) = PrepareTwoNumericArgs(args);
 
         if (a is null || b is null)
         {

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

@@ -15,8 +15,8 @@ namespace Altinn.App.Core.Internal.Expressions;
 {
     private readonly string? _stringValue = null;
 
-    // double is a value type where nullable takes extra space, and we only read it when it should be set
-    private readonly double _numberValue = 0;
+    // decimal is a value type where nullable takes extra space, and we only read it when it should be set
+    private readonly decimal _numberValue = 0;
 
     // private readonly Dictionary<string, ExpressionValue>? _objectValue = null;
     // private readonly ExpressionValue[]? _arrayValue = null;
@@ -64,7 +64,7 @@ private ExpressionValue(bool? value)
         }
     }
 
-    private ExpressionValue(double? value)
+    private ExpressionValue(decimal? value)
     {
         if (value.HasValue)
         {
@@ -101,9 +101,9 @@ private ExpressionValue(string? value)
     public static implicit operator ExpressionValue(bool? value) => new(value);
 
     /// <summary>
-    /// Convert a nullable double to ExpressionValue
+    /// Convert a nullable decimal to ExpressionValue
     /// </summary>
-    public static implicit operator ExpressionValue(double? value) => new(value);
+    public static implicit operator ExpressionValue(decimal? value) => new(value);
 
     /// <summary>
     /// Convert a nullable string to ExpressionValue
@@ -131,8 +131,8 @@ public static ExpressionValue FromObject(object? value)
             null => Null,
             bool boolValue => boolValue,
             string stringValue => stringValue,
-            float numberValue => numberValue,
-            double numberValue => numberValue,
+            float numberValue => ValidateAndCastFloatingPoint(numberValue), // expressions uses decimal which needs an explicit cast
+            double numberValue => ValidateAndCastFloatingPoint(numberValue), // expressions uses decimal which needs an explicit cast
             byte numberValue => numberValue,
             sbyte numberValue => numberValue,
             short numberValue => numberValue,
@@ -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 => numberValue,
             DateTime dateTimeValue => JsonSerializer
                 .Serialize(dateTimeValue, _unsafeSerializerOptionsForSerializingDates)
                 .Trim(
@@ -229,7 +227,7 @@ public static ExpressionValue FromObject(object? value)
     /// <summary>
     /// Get the value as a number (or throw if it isn't a number ValueKind)
     /// </summary>
-    public double Number =>
+    public decimal Number =>
         ValueKind switch
         {
             JsonValueKind.Number => _numberValue,
@@ -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)
@@ -589,6 +587,23 @@ private static bool IsSupportedNumericType(Type type)
             || type == typeof(ushort)
             || type == typeof(sbyte);
     }
+
+    private static decimal? ValidateAndCastFloatingPoint(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 (decimal?)value;
+    }
 }
 
 /// <summary>
@@ -604,7 +619,7 @@ public override ExpressionValue Read(ref Utf8JsonReader reader, Type typeToConve
             JsonTokenType.True => true,
             JsonTokenType.False => false,
             JsonTokenType.String => reader.GetString(),
-            JsonTokenType.Number => reader.GetDouble(),
+            JsonTokenType.Number => reader.GetDecimal(),
             JsonTokenType.Null => ExpressionValue.Null,
             // JsonTokenType.StartObject => ReadObject(ref reader),
             // JsonTokenType.StartArray => ReadArray(ref reader),

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

@@ -27,7 +27,7 @@ public static Expression ReadStatic(JsonElement element) =>
             JsonValueKind.True => new Expression(true),
             JsonValueKind.False => new Expression(false),
             JsonValueKind.String => new Expression(element.GetString()),
-            JsonValueKind.Number => new Expression(element.GetDouble()),
+            JsonValueKind.Number => new Expression(element.GetDecimal()),
             JsonValueKind.Null => new Expression(ExpressionValue.Null),
             JsonValueKind.Array => ReadArray(element),
             JsonValueKind.Object => throw new JsonException("Invalid type \"object\""),
@@ -44,7 +44,7 @@ public static Expression ReadStatic(ref Utf8JsonReader reader, JsonSerializerOpt
             JsonTokenType.True => new Expression(true),
             JsonTokenType.False => new Expression(false),
             JsonTokenType.String => new Expression(reader.GetString()),
-            JsonTokenType.Number => new Expression(reader.GetDouble()),
+            JsonTokenType.Number => new Expression(reader.GetDecimal()),
             JsonTokenType.Null => new Expression(ExpressionValue.Null),
             JsonTokenType.StartArray => ReadArray(ref reader, options),
             JsonTokenType.StartObject => throw new JsonException("Invalid type \"object\""),

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/TestFunctions.cs

@@ -203,6 +203,26 @@ public TestFunctions(ITestOutputHelper output)
     [SharedTest("stringLength")]
     public async Task StringLength_Theory(string testName, string folder) => await RunTestCase(testName, folder);
 
+    [Theory]
+    [SharedTest("plus")]
+    public async Task Plus_Theory(string testName, string folder) => await RunTestCase(testName, folder);
+
+    [Theory]
+    [SharedTest("minus")]
+    public async Task Minus_Theory(string testName, string folder) => await RunTestCase(testName, folder);
+
+    [Theory]
+    [SharedTest("multiply")]
+    public async Task Multiply_Theory(string testName, string folder) => await RunTestCase(testName, folder);
+
+    [Theory]
+    [SharedTest("divide")]
+    public async Task Divide_Theory(string testName, string folder) => await RunTestCase(testName, folder);
+
+    [Theory]
+    [SharedTest("average")]
+    public async Task Average_Theory(string testName, string folder) => await RunTestCase(testName, folder);
+
     [Theory]
     [SharedTest("round")]
     public async Task Round_Theory(string testName, string folder) => await RunTestCase(testName, folder);
@@ -431,7 +451,7 @@ private async Task RunTestCaseItem(
                 Assert.Null(result);
                 break;
             case JsonValueKind.Number:
-                Assert.Equal(test.Expects.GetDouble(), result);
+                Assert.Equal(test.Expects.GetDecimal(), result);
                 break;
             case JsonValueKind.Undefined:
 

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/divide/divide-by-zero.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should throw exception when trying to divide by zero",
+  "expression": ["divide", 15, 0],
+  "expectsFailure": "At least one of the arguments after the first is 0, cannot divide by 0"
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/divide/divide-decimals.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should divide the first argument with the second",
+  "expression": ["divide", 0.1, 0.2],
+  "expects": 0.5
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/divide/divide-multiple-decimals.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should throw exception when more then two arguments is present",
+  "expression": ["divide", 0.1, 0.2, 15, 1.50],
+  "expectsFailure": "Invalid number of args for compare"
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/divide/divide-negative-values.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should divide the first argument with the second",
+  "expression": ["divide", -0.1, -0.2],
+  "expects": 0.5
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/divide/divide-null-values.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should throw exception when both of the arguments are null",
+  "expression": ["divide", null, null],
+  "expectsFailure": "At least one of the arguments is not a number"
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/divide/divide-one-argument.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should throw exception when less than two arguments are provided",
+  "expression": ["divide", 2.1],
+  "expectsFailure": "At least two arguments must be provided"
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/divide/divide-one-null-value.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should throw exception when one of the arguments is null",
+  "expression": ["divide", null, 2.1],
+  "expectsFailure": "At least one of the arguments is not a number"
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/minus/subtracting-decimals.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should subtract the second argument from the first",
+  "expression": ["minus", 0.1, 0.2],
+  "expects": -0.1
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/minus/subtracting-multiple-decimals.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should throw exception when more then two arguments is present",
+  "expression": ["minus", 0.1, 0.2, 15, 1.50],
+  "expectsFailure": "Invalid number of args for compare"
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/minus/subtracting-negative-values.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should subtract the second negative argument from the first",
+  "expression": ["minus", -0.1, -0.2],
+  "expects": 0.1
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/minus/subtracting-no-arguments.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should return 0 when no arguments are provided",
+  "expression": ["minus"],
+  "expects": 0
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/minus/subtracting-null-values.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should throw exception when both of the arguments are null",
+  "expression": ["minus", null, null],
+  "expectsFailure": "At least one of the arguments is not a number"
+}

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/shared-tests/functions/minus/subtracting-one-null-value.json

@@ -0,0 +1,5 @@
+{
+  "name": "Should throw exception when one of the arguments is null",
+  "expression": ["minus", null, 2.1],
+  "expectsFailure": "At least one of the arguments is not a number"
+}