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); + } +}