Fix rounding and add tests; tests are taken from Jaded-Encoding-Thaumaturgy/akarin-vapoursynth-plugin#12 and https://github.com/vapoursynth/vapoursynth/blob/master/test/expr_test.py

Author: yuygfgg

llvmexpr/llvmexpr.cpp

@@ -2172,7 +2172,9 @@ class Compiler {
             llvm::Value* clamped_f =
                 createBinaryIntrinsicCall(llvm::Intrinsic::minnum, temp, max_f);
 
-            final_val = builder.CreateFPToUI(clamped_f, builder.getInt32Ty());
+            llvm::Value* rounded_f =
+                createUnaryIntrinsicCall(llvm::Intrinsic::roundeven, clamped_f);
+            final_val = builder.CreateFPToUI(rounded_f, builder.getInt32Ty());
 
             if (bpp == 1) {
                 final_val = builder.CreateTrunc(final_val, builder.getInt8Ty());

pytest.ini

@@ -0,0 +1,19 @@
+; Copyright (C) 2025 yuygfgg
+; 
+; This file is part of Vapoursynth-llvmexpr.
+; 
+; Vapoursynth-llvmexpr is free software: you can redistribute it and/or modify
+; it under the terms of the GNU General Public License as published by
+; the Free Software Foundation, either version 3 of the License, or
+; (at your option) any later version.
+; 
+; Vapoursynth-llvmexpr is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+; GNU General Public License for more details.
+; 
+; You should have received a copy of the GNU General Public License
+; along with Vapoursynth-llvmexpr.  If not, see <https://www.gnu.org/licenses/>.
+
+[pytest]
+addopts = -p no:vsengine

tests/test_expr.py

@@ -0,0 +1,293 @@
+"""
+Copyright (C) 2025 sgt0
+Copyright (C) 2025 yuygfgg
+
+This file is part of Vapoursynth-llvmexpr.
+
+This file is derived from and has been modified from code
+originally contributed by sgt0 in a pull request to the akarin-vapoursynth-plugin
+project (https://github.com/Jaded-Encoding-Thaumaturgy/akarin-vapoursynth-plugin/pull/12),
+which was licensed under LGPLv3.
+
+As Vapoursynth-llvmexpr is licensed under the GNU General Public License v3, this
+modified file is also distributed under the same license.
+
+Vapoursynth-llvmexpr is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Vapoursynth-llvmexpr is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Vapoursynth-llvmexpr.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+import pytest
+import vapoursynth as vs
+
+core = vs.core
+
+
+@pytest.mark.parametrize(
+    "input_format, a, b, expr, expected",
+    [
+        (vs.GRAYS, 2.0, 3.0, "x y +", 5.0),
+        (vs.GRAYS, 7.0, 5.0, "x y -", 2.0),
+        (vs.GRAYS, 4.0, 2.5, "x y *", 10.0),
+        (vs.GRAYS, 7.5, 2.5, "x y /", 3.0),
+        (vs.GRAYS, 5.25, 1.0, "x 1.0 %", 0.25),
+    ],
+)
+def test_arithmetic(
+    input_format: int, a: float, b: float, expr: str, expected: float
+) -> None:
+    c1 = core.std.BlankClip(format=input_format, color=a)
+    c2 = core.std.BlankClip(format=input_format, color=b)
+    res = core.llvmexpr.Expr([c1, c2], expr, vs.GRAYS)
+    assert res.get_frame(0)[0][0, 0] == pytest.approx(expected)
+
+
+@pytest.mark.parametrize(
+    "a, b, expr, expected",
+    [
+        (3.0, 2.0, "x y >", 1.0),
+        (2.0, 3.0, "x y <", 1.0),
+        (3.0, 3.0, "x y =", 1.0),
+        (3.0, 3.0, "x y >=", 1.0),
+        (2.0, 3.0, "x y <=", 1.0),
+        (1.0, 0.0, "x y and", 0.0),
+        (1.0, 0.0, "x y or", 1.0),
+        (1.0, 1.0, "x y xor", 0.0),
+        (0.0, 0.0, "x not", 1.0),
+        (-2, -3, "x y and", 0.0),
+        (-2, -1, "x y or", 0.0),
+        (-2, -1, "x y xor", 0.0),
+        (-2, 3, "x y xor", 1.0),
+    ],
+)
+def test_comparison_and_logical(a: float, b: float, expr: str, expected: float) -> None:
+    c1 = core.std.BlankClip(format=vs.GRAYS, color=a)
+    c2 = core.std.BlankClip(format=vs.GRAYS, color=b)
+    res = core.llvmexpr.Expr([c1, c2], expr, vs.GRAYS)
+    assert res.get_frame(0)[0][0, 0] == pytest.approx(expected)
+
+
+@pytest.mark.parametrize(
+    "input_format, input_value, expr, expected",
+    [
+        (vs.GRAY8, 0, "0 exp", 1.0),
+        (vs.GRAY8, 0, "x exp", 1.0),
+        (vs.GRAY8, 1, "x exp", 2.71828),
+        (vs.GRAYS, 0.5, "x exp", 1.64872),
+    ],
+)
+def test_exp(input_format: int, input_value: int, expr: str, expected: float) -> None:
+    clip = core.std.BlankClip(format=input_format, color=input_value)
+    result = core.llvmexpr.Expr(clip, expr, vs.GRAYS)
+    assert result.get_frame(0)[0][0, 0] == pytest.approx(expected)
+
+
+@pytest.mark.parametrize(
+    "input_format, input_value, expr, expected",
+    [
+        (vs.GRAY8, 0, "0 log", float("-inf")),
+        (
+            vs.GRAY8,
+            0,
+            "x log",
+            float("-inf"),
+        ),  # differs from std.Expr's -87.3365478515625
+        (vs.GRAY8, 1, "x log", 0),
+        (vs.GRAYS, 7.38905, "x log", 2),
+    ],
+)
+def test_log(input_format: int, input_value: int, expr: str, expected: float) -> None:
+    clip = core.std.BlankClip(format=input_format, color=input_value)
+    result = core.llvmexpr.Expr(clip, expr, vs.GRAYS)
+    assert result.get_frame(0)[0][0, 0] == pytest.approx(expected)
+
+
+@pytest.mark.parametrize(
+    "val, expr, expected",
+    [
+        (1.9, "x floor", 1.0),
+        (1.1, "x ceil", 2.0),
+        (2.49, "x round", 2.0),
+        (2.5, "x round", 3.0),
+        (-2.9, "x trunc", -2.0),
+        (2.9, "x abs", 2.9),
+        (3.0, "x neg", -3.0),
+        (-5.0, "x sgn", -1.0),
+        (0.0, "x sgn", 0.0),
+        (7.0, "x sgn", 1.0),
+        (2.0, "x -3 copysign", -2.0),
+        (2.0, "2 3 4 fma", 10.0),
+    ],
+)
+def test_rounding_and_misc(val: float, expr: str, expected: float) -> None:
+    c = core.std.BlankClip(format=vs.GRAYS, color=val)
+    res = core.llvmexpr.Expr(c, expr, vs.GRAYS)
+    assert res.get_frame(0)[0][0, 0] == pytest.approx(expected)
+
+
+@pytest.mark.parametrize("input_format", [vs.GRAY8, vs.GRAY16, vs.GRAYS])
+@pytest.mark.parametrize(
+    "expr, expected",
+    [
+        ("x 1.5 pow", 0.0),
+    ],
+)
+def test_pow(input_format: int, expr: str, expected: float) -> None:
+    clip = core.std.BlankClip(format=input_format, color=0)
+    result = core.llvmexpr.Expr(clip, expr, vs.GRAYS)
+    assert result.get_frame(0)[0][0, 0] == pytest.approx(expected)
+
+
+@pytest.mark.parametrize(
+    "input_format, input_value, expr, expected",
+    [
+        (vs.GRAY8, 0, "x sin", 0),
+        (vs.GRAY8, 1, "x sin", 0.8414709568023682),
+        (vs.GRAY8, 2, "x sin", 0.9092974066734314),
+    ],
+)
+def test_sin(input_format: int, input_value: int, expr: str, expected: float) -> None:
+    clip = core.std.BlankClip(format=input_format, color=input_value)
+    result = core.llvmexpr.Expr(clip, expr, vs.GRAYS)
+    assert result.get_frame(0)[0][0, 0] == pytest.approx(expected)
+
+
+def test_gh_11() -> None:
+    clip = core.std.BlankClip(format=vs.GRAY8, color=0)
+    result = core.llvmexpr.Expr(clip, "x 128 / 0.86 pow 255 *")
+    assert result.get_frame(0)[0][0, 0] == pytest.approx(6.122468756907559e-31)
+
+    clip = core.std.BlankClip(format=vs.GRAY16, color=0)
+    result = core.llvmexpr.Expr(clip, "x 32768 / 0.86 pow 65535 *")
+    assert result.get_frame(0)[0][0, 0] == pytest.approx(1.5734745330615421e-28)
+
+
+@pytest.mark.parametrize(
+    "val, min_v, max_v, expected_max, expected_min",
+    [
+        (5.0, 2.0, 8.0, 8.0, 2.0),
+        (1.0, 2.0, 8.0, 2.0, 1.0),
+    ],
+)
+def test_min_max_clip(
+    val: float, min_v: float, max_v: float, expected_max: float, expected_min: float
+) -> None:
+    c = core.std.BlankClip(format=vs.GRAYS, color=val)
+    res_max = core.llvmexpr.Expr(c, "x 3 max", vs.GRAYS)
+    res_min = core.llvmexpr.Expr(c, "x 3 min", vs.GRAYS)
+    res_clip = core.llvmexpr.Expr(c, f"x {min_v} {max_v} clip", vs.GRAYS)
+    assert res_max.get_frame(0)[0][0, 0] == pytest.approx(max(val, 3.0))
+    assert res_min.get_frame(0)[0][0, 0] == pytest.approx(min(val, 3.0))
+    assert res_clip.get_frame(0)[0][0, 0] == pytest.approx(min(max(val, min_v), max_v))
+
+
+@pytest.mark.parametrize(
+    "a, b, expr, expected",
+    [
+        (5.9, 1.0, "x y bitand", 1.0),
+        (5.0, 2.0, "x y bitor", 7.0),
+        (5.0, 1.0, "x y bitxor", 4.0),
+        (
+            5.0,
+            0.0,
+            "x bitnot",
+            (
+                float(2**32 - 1 - 5)
+                if vs.core.core_version.release_major
+                >= 64  # pyright: ignore[reportOperatorIssue]
+                else float(~5 & 0xFFFFFFFF)
+            ),
+        ),
+    ],
+)
+def test_bitwise(a: float, b: float, expr: str, expected: float) -> None:
+    c1 = core.std.BlankClip(format=vs.GRAYS, color=a)
+    c2 = core.std.BlankClip(format=vs.GRAYS, color=b)
+    res = core.llvmexpr.Expr([c1, c2], expr, vs.GRAYS)
+    # bitnot result depends on implementation width; for generality, compare masked
+    out = res.get_frame(0)[0][0, 0]
+    if "bitnot" in expr:
+        assert int(out) & 0xFFFFFFFF == (~int(a)) & 0xFFFFFFFF
+    else:
+        assert out == pytest.approx(expected)
+
+
+def test_stack_manipulation() -> None:
+    c = core.std.BlankClip(format=vs.GRAYS, color=3.0)
+    res_dup = core.llvmexpr.Expr(c, "x dup *", vs.GRAYS)
+    assert res_dup.get_frame(0)[0][0, 0] == pytest.approx(9.0)
+    c0 = core.std.BlankClip(format=vs.GRAYS, color=0.0)
+    res_swap = core.llvmexpr.Expr(c0, "2 5 swap -", vs.GRAYS)
+    assert res_swap.get_frame(0)[0][0, 0] == pytest.approx(3.0)
+    res_drop = core.llvmexpr.Expr(c0, "1 2 3 drop2", vs.GRAYS)
+    assert res_drop.get_frame(0)[0][0, 0] == pytest.approx(1.0)
+    res_sort = core.llvmexpr.Expr(c0, "3 1 2 sort3 drop2", vs.GRAYS)
+    assert res_sort.get_frame(0)[0][0, 0] == pytest.approx(1.0)
+
+
+def test_named_variables_and_loop_power() -> None:
+    c = core.std.BlankClip(format=vs.GRAYS, color=2.0)
+    y = core.std.BlankClip(format=vs.GRAYS, color=4.0)
+    expr = "x base! 1 result! y counter! #loop result@ base@ * result! counter@ 1 - counter! counter@ loop# result@"
+    res = core.llvmexpr.Expr([c, y], expr, vs.GRAYS)
+    assert res.get_frame(0)[0][0, 0] == pytest.approx(16.0)
+
+
+def test_constants_and_coords() -> None:
+    c0 = core.std.BlankClip(format=vs.GRAYS, color=0.0, width=3, height=2)
+    res_pi = core.llvmexpr.Expr(c0, "pi", vs.GRAYS)
+    assert res_pi.get_frame(0)[0][0, 0] == pytest.approx(3.14159265, rel=1e-6)
+    res_N = core.llvmexpr.Expr(c0, "N", vs.GRAYS)
+    assert res_N.get_frame(3)[0][0, 0] == pytest.approx(3.0)
+    res_wh = core.llvmexpr.Expr(c0, "width height +", vs.GRAYS)
+    assert res_wh.get_frame(0)[0][0, 0] == pytest.approx(5.0)
+    res_X = core.llvmexpr.Expr(c0, "X", vs.GRAYS)
+    res_Y = core.llvmexpr.Expr(c0, "Y", vs.GRAYS)
+    fX = res_X.get_frame(0)
+    fY = res_Y.get_frame(0)
+    assert fX[0][1, 2] == pytest.approx(2.0)
+    assert fY[0][1, 2] == pytest.approx(1.0)
+
+
+def test_conditional_ternary() -> None:
+    c = core.std.BlankClip(format=vs.GRAYS, color=10.0)
+    res = core.llvmexpr.Expr(c, "x 5 > 1 0 ?", vs.GRAYS)
+    assert res.get_frame(0)[0][0, 0] == pytest.approx(1.0)
+
+
+def test_pixel_access_static_and_dynamic() -> None:
+    base = core.std.BlankClip(format=vs.GRAYS, color=0.0, width=4, height=2)
+    ramp = core.llvmexpr.Expr(base, "X", vs.GRAYS)
+    src = core.std.BlankClip(format=vs.GRAYS, color=99.0, width=4, height=2)
+    expr_rel = "y[-1,0]"
+    res_rel = core.llvmexpr.Expr([src, ramp], expr_rel, vs.GRAYS)
+    f = res_rel.get_frame(0)
+    assert f[0][0, 2] == pytest.approx(1.0)
+    expr_abs = "1 1 y[]"
+    res_abs = core.llvmexpr.Expr([src, ramp], expr_abs, vs.GRAYS)
+    assert res_abs.get_frame(0)[0][0, 0] == pytest.approx(1.0)
+
+
+def test_frame_property_access() -> None:
+    c = core.std.BlankClip(format=vs.GRAYS, color=0.0)
+    c = core.std.SetFrameProps(c, _TestProp=0.25)
+    res = core.llvmexpr.Expr(c, "x._TestProp", vs.GRAYS)
+    assert res.get_frame(0)[0][0, 0] == pytest.approx(0.25)
+
+
+def test_direct_output_write_and_exit() -> None:
+    base = core.std.BlankClip(format=vs.GRAYS, color=0.0, width=4, height=4)
+    expr = "X 1 = Y 2 = and 5 1 2 @[] ^exit^ 0 ?"
+    res = core.llvmexpr.Expr(base, expr, vs.GRAYS)
+    fr = res.get_frame(0)
+    assert fr[0][2, 1] == pytest.approx(5.0)
+    assert fr[0][0, 0] == pytest.approx(0.0)