diff --git a/optimizer/sum_array.go b/optimizer/sum_array.go index 3c96795ef..86a5b0b17 100644 --- a/optimizer/sum_array.go +++ b/optimizer/sum_array.go @@ -1,8 +1,6 @@ package optimizer import ( - "fmt" - . "github.com/expr-lang/expr/ast" ) @@ -14,24 +12,22 @@ func (*sumArray) Visit(node *Node) { len(sumBuiltin.Arguments) == 1 { if array, ok := sumBuiltin.Arguments[0].(*ArrayNode); ok && len(array.Nodes) >= 2 { - patchCopyType(node, sumArrayFold(array)) + patchCopyType(node, sumArrayFold(array.Nodes)) } } } -func sumArrayFold(array *ArrayNode) *BinaryNode { - if len(array.Nodes) > 2 { - return &BinaryNode{ - Operator: "+", - Left: array.Nodes[0], - Right: sumArrayFold(&ArrayNode{Nodes: array.Nodes[1:]}), - } - } else if len(array.Nodes) == 2 { - return &BinaryNode{ +// sumArrayFold builds ((a + b) + c) + ..., adding the elements left to right +// like sum() does at runtime. Float addition is not associative, so any other +// grouping can give a different result than the unoptimized program. +func sumArrayFold(nodes []Node) Node { + result := nodes[0] + for _, n := range nodes[1:] { + result = &BinaryNode{ Operator: "+", - Left: array.Nodes[0], - Right: array.Nodes[1], + Left: result, + Right: n, } } - panic(fmt.Errorf("sumArrayFold: invalid array length %d", len(array.Nodes))) + return result } diff --git a/optimizer/sum_array_test.go b/optimizer/sum_array_test.go index 6ff93e350..3d20483ed 100644 --- a/optimizer/sum_array_test.go +++ b/optimizer/sum_array_test.go @@ -60,13 +60,54 @@ func TestOptimize_sum_array_3(t *testing.T) { expected := &ast.BinaryNode{ Operator: "+", - Left: &ast.IdentifierNode{Value: "a"}, - Right: &ast.BinaryNode{ + Left: &ast.BinaryNode{ Operator: "+", - Left: &ast.IdentifierNode{Value: "b"}, - Right: &ast.IdentifierNode{Value: "c"}, + Left: &ast.IdentifierNode{Value: "a"}, + Right: &ast.IdentifierNode{Value: "b"}, }, + Right: &ast.IdentifierNode{Value: "c"}, } assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) } + +func TestOptimize_sum_array_float_order(t *testing.T) { + // sum() adds left to right, so the optimized program must too: + // 1e16 + -1e16 + 1 is 1, but 1e16 + (-1e16 + 1) is 0. + x, y, z := 0.1, 0.2, 0.3 + env := map[string]any{ + "a": 1e16, + "b": -1e16, + "c": 1.0, + "x": x, + "y": y, + "z": z, + } + + tests := []struct { + code string + want any + }{ + {`sum([a, b, c])`, 1.0}, + {`sum([x, y, z])`, x + y + z}, + {`sum([x, y, z]) == x + y + z`, true}, + } + + for _, tt := range tests { + t.Run(tt.code, func(t *testing.T) { + program, err := expr.Compile(tt.code, expr.Env(env)) + require.NoError(t, err) + + out, err := expr.Run(program, env) + require.NoError(t, err) + assert.Equal(t, tt.want, out) + + unoptimized, err := expr.Compile(tt.code, expr.Env(env), expr.Optimize(false)) + require.NoError(t, err) + + want, err := expr.Run(unoptimized, env) + require.NoError(t, err) + assert.Equal(t, want, out) + }) + } +}