Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 11 additions & 15 deletions optimizer/sum_array.go
Original file line number Diff line number Diff line change
@@ -1,8 +1,6 @@
package optimizer

import (
"fmt"

. "github.com/expr-lang/expr/ast"
)

Expand All @@ -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
}
49 changes: 45 additions & 4 deletions optimizer/sum_array_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
})
}
}