From 0d4ae730804cf43fd2fe86f6a60b1227e33360cc Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 18 Nov 2026 05:29:23 +0000 Subject: [PATCH] Fix unary minus directly after ^ in the bundled Javaluator A prefix operator has no left operand, so it must never pop a pending operator off the stack. The shunting-yard loop let unary minus (precedence 3) pop a pending ^ (precedence 4), which then ran before its right operand was read: `x * 2^-1` returned -900 for x=30 and a bare `2^-1` was rejected. Skip the pop loop for unary operators. Both the string and the compiled evaluator share this parser. The existing test that pinned the rejection of `2^-1` now checks that the compiled and string evaluators agree. Fixes #197 Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01FaEyTsM3SWu5hP2sUDjCjR --- .../eval/javaluator/AbstractEvaluator.java | 4 +- .../util/eval/CompiledExpressionTest.java | 11 +-- .../codex/util/eval/NegativeExponentTest.java | 68 +++++++++++++++++++ 3 files changed, 77 insertions(+), 6 deletions(-) create mode 100644 codex-api/src/test/java/studio/magemonkey/codex/util/eval/NegativeExponentTest.java diff --git a/codex-api/src/main/java/studio/magemonkey/codex/util/eval/javaluator/AbstractEvaluator.java b/codex-api/src/main/java/studio/magemonkey/codex/util/eval/javaluator/AbstractEvaluator.java index 3859ed54..d6ca651e 100644 --- a/codex-api/src/main/java/studio/magemonkey/codex/util/eval/javaluator/AbstractEvaluator.java +++ b/codex-api/src/main/java/studio/magemonkey/codex/util/eval/javaluator/AbstractEvaluator.java @@ -330,7 +330,9 @@ public T evaluate(String expression, EvaluationContext evaluationContext) { break; case OPERATOR: // If the token is an operator, op1, then: - while (!stack.isEmpty()) { + // A prefix (unary) operator has no left operand, so it must never pop a pending operator: + // in "x * 2^-1" popping "^" would apply it before its right operand has been read. + while (token.getOperator().getOperandCount() > 1 && !stack.isEmpty()) { Token sc = stack.peek(); // While there is an operator token, o2, at the top of the stack // op1 is left-associative and its precedence is less than or equal diff --git a/codex-api/src/test/java/studio/magemonkey/codex/util/eval/CompiledExpressionTest.java b/codex-api/src/test/java/studio/magemonkey/codex/util/eval/CompiledExpressionTest.java index 9976a556..5742f51c 100644 --- a/codex-api/src/test/java/studio/magemonkey/codex/util/eval/CompiledExpressionTest.java +++ b/codex-api/src/test/java/studio/magemonkey/codex/util/eval/CompiledExpressionTest.java @@ -159,11 +159,12 @@ void damageFormulaMatchesHandWrittenJava() { } @ParameterizedTest - @ValueSource(strings = {"2^-1", "-d^-x", "d^-1"}) - void unaryMinusRightAfterExponentIsRejectedLikeDoubleEvaluatorDoes(String expression) { - // The shared parser pops "^" when it meets a unary minus (lower precedence), leaving it one operand short. - assertThrows(RuntimeException.class, () -> reference(expression, NAMES, VALUE_SETS[0])); - assertMessage(compileFails(expression, NAMES), expression); + @ValueSource(strings = {"2^-1", "-d^-x", "d^-1", "x * 2^-1"}) + void unaryMinusRightAfterExponentMatchesDoubleEvaluator(String expression) { + // A unary minus after "^" binds to its own operand, so these evaluate (see NegativeExponentTest for values). + double[] v = VALUE_SETS[0]; + assertEquals(Double.doubleToLongBits(reference(expression, NAMES, v)), + Double.doubleToLongBits(Evaluator.compile(expression, NAMES).eval(v)), expression); } @Test diff --git a/codex-api/src/test/java/studio/magemonkey/codex/util/eval/NegativeExponentTest.java b/codex-api/src/test/java/studio/magemonkey/codex/util/eval/NegativeExponentTest.java new file mode 100644 index 00000000..468764fc --- /dev/null +++ b/codex-api/src/test/java/studio/magemonkey/codex/util/eval/NegativeExponentTest.java @@ -0,0 +1,68 @@ +package studio.magemonkey.codex.util.eval; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import studio.magemonkey.codex.util.eval.javaluator.DoubleEvaluator; +import studio.magemonkey.codex.util.eval.javaluator.StaticVariableSet; + +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +/** A unary minus right after {@code ^} must evaluate correctly (never a silently wrong number), in both evaluators. */ +class NegativeExponentTest { + private static final double X = 30; + + static Stream cases() { + return Stream.of( + Arguments.of("2^-1", 0.5), + Arguments.of("x * 2^-1", 15.0), + Arguments.of("x*2^-1", 15.0), + Arguments.of("2^-x", Math.pow(2, -X)), + Arguments.of("x + 2^-1", X + 0.5), + Arguments.of("x - 2^-1", X - 0.5), + Arguments.of("1 + x * 2^-1 * 2", 1 + X), + Arguments.of("2^-1 * x", 15.0), + Arguments.of("2^--1", 2.0), + Arguments.of("2^---1", 0.5), + Arguments.of("2^-(1+1)", 0.25), + Arguments.of("2^-1^2", 0.5), + Arguments.of("2^-3^2", Math.pow(2, -9)), + Arguments.of("-2^2", -4.0), + Arguments.of("-2^-2", -0.25), + Arguments.of("x * -2^2", -120.0), + Arguments.of("(2^-1)", 0.5), + Arguments.of("max(2^-1, 0)", 0.5), + Arguments.of("max(1, x * 2^-1)", 15.0), + Arguments.of("x * 2^(-1)", 15.0), + Arguments.of("2^(-1)", 0.5), + Arguments.of("1 - -1", 2.0), + Arguments.of("2 * -3", -6.0), + Arguments.of("2 ^ - 1", 0.5), + Arguments.of("4^-0.5", 0.5)); + } + + @ParameterizedTest(name = "[{index}] {0}") + @MethodSource("cases") + void compiled(String expression, double expected) { + assertEquals(expected, Evaluator.compile(expression, "x").eval(X), 1e-12, expression); + } + + @ParameterizedTest(name = "[{index}] {0}") + @MethodSource("cases") + void stringEvaluator(String expression, double expected) { + StaticVariableSet vars = new StaticVariableSet<>(); + vars.set("x", X); + assertEquals(expected, new DoubleEvaluator().evaluate(expression, vars), 1e-12, expression); + } + + @Test + void excelStyleUnchanged() { + DoubleEvaluator excel = new DoubleEvaluator(DoubleEvaluator.getDefaultParameters(DoubleEvaluator.Style.EXCEL)); + assertEquals(4.0, excel.evaluate("-2^2"), 0); + assertEquals(15.0, excel.evaluate("30 * 2^-1"), 1e-12); + assertEquals(0.5, excel.evaluate("2^-1"), 1e-12); + } +}