From 91986112a1d5a05cf23c1512cd973d4545292305 Mon Sep 17 00:00:00 2001 From: Danila Fedorin Date: Wed, 6 Sep 2017 21:43:07 -0700 Subject: [PATCH] Switch all applicables to use the Context. --- .../abacus/function/EvaluationException.java | 25 ++ .../nwapw/abacus/plugin/StandardPlugin.java | 242 +++++++++--------- .../main/kotlin/org/nwapw/abacus/Abacus.kt | 2 +- .../abacus/function/TreeValueFunction.kt | 4 +- .../abacus/function/TreeValueOperator.kt | 4 +- .../abacus/function/applicable/Applicable.kt | 12 +- .../function/applicable/ReducerApplicable.kt | 45 ---- .../org/nwapw/abacus/tree/NumberReducer.kt | 26 +- .../nwapw/abacus/tests/TokenizerTests.java | 22 +- 9 files changed, 191 insertions(+), 191 deletions(-) create mode 100644 core/src/main/java/org/nwapw/abacus/function/EvaluationException.java delete mode 100644 core/src/main/kotlin/org/nwapw/abacus/function/applicable/ReducerApplicable.kt diff --git a/core/src/main/java/org/nwapw/abacus/function/EvaluationException.java b/core/src/main/java/org/nwapw/abacus/function/EvaluationException.java new file mode 100644 index 0000000..bad85b9 --- /dev/null +++ b/core/src/main/java/org/nwapw/abacus/function/EvaluationException.java @@ -0,0 +1,25 @@ +package org.nwapw.abacus.function; + +/** + * An exception thrown primarily from Tree Value operators and functions, + * which have to deal with the result of a Reducer as well as the results + * of Applicable. + */ +public class EvaluationException extends RuntimeException { + + /** + * Creates a new EvaluationException with the default string. + */ + public EvaluationException() { + super("Error evaluating expression."); + } + + /** + * Creates a new EvaluationError with the given message string. + * @param message the message string. + */ + public EvaluationException(String message) { + super(message); + } + +} diff --git a/core/src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java b/core/src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java index b4f919a..5e7069e 100755 --- a/core/src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java +++ b/core/src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java @@ -1,7 +1,6 @@ package org.nwapw.abacus.plugin; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; +import org.nwapw.abacus.context.MutableReductionContext; import org.nwapw.abacus.function.*; import org.nwapw.abacus.number.NaiveNumber; import org.nwapw.abacus.number.NumberInterface; @@ -24,15 +23,16 @@ public class StandardPlugin extends Plugin { */ public final TreeValueOperator opSet = new TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) { @Override - public boolean matchesParams(NumberImplementation implementation, TreeNode[] params) { + public boolean matchesParams(MutableReductionContext context, TreeNode[] params) { return params.length == 2 && params[0] instanceof VariableNode; } @Override - public NumberInterface applyWithReducerInternal(NumberImplementation implementation, Reducer reducer, TreeNode[] params) { + public NumberInterface applyInternal(MutableReductionContext context, TreeNode[] params) { String assignTo = ((VariableNode) params[0]).getVariable(); - NumberInterface value = params[1].reduce(reducer); - getVariableDatabase().getVariables().put(assignTo, value); + NumberInterface value = params[1].reduce(context.getReducer()); + if(value == null) throw new EvaluationException(); + context.setVariable(assignTo, value); return value; } }; @@ -41,16 +41,17 @@ public class StandardPlugin extends Plugin { */ public final TreeValueOperator opDefine = new TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) { @Override - public boolean matchesParams(NumberImplementation implementation, TreeNode[] params) { + public boolean matchesParams(MutableReductionContext context, TreeNode[] params) { return params.length == 2 && params[0] instanceof VariableNode; } - @Nullable @Override - public NumberInterface applyWithReducerInternal(NumberImplementation implementation, Reducer reducer, TreeNode[] params) { + public NumberInterface applyInternal(MutableReductionContext context, TreeNode[] params) { String assignTo = ((VariableNode) params[0]).getVariable(); - getVariableDatabase().getDefinitions().put(assignTo, params[1]); - return params[1].reduce(reducer); + context.setDefinition(assignTo, params[1]); + NumberInterface value = params[1].reduce(context.getReducer()); + if(value == null) throw new EvaluationException(); + return value; } }; /** @@ -58,12 +59,12 @@ public class StandardPlugin extends Plugin { */ public static final NumberOperator OP_ADD = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 2; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { return params[0].add(params[1]); } }; @@ -72,12 +73,12 @@ public class StandardPlugin extends Plugin { */ public static final NumberOperator OP_SUBTRACT = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 2; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { return params[0].subtract(params[1]); } @@ -87,12 +88,12 @@ public class StandardPlugin extends Plugin { */ public static final NumberOperator OP_NEGATE = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.UNARY_PREFIX, 0) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { return params[0].negate(); } }; @@ -101,12 +102,12 @@ public class StandardPlugin extends Plugin { */ public static final NumberOperator OP_MULTIPLY = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 2; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { return params[0].multiply(params[1]); } }; @@ -135,7 +136,8 @@ public class StandardPlugin extends Plugin { @Override public NumberInterface instanceForPi() { - NumberInterface C = FUNCTION_SQRT.apply(this, new PreciseNumber("10005")).multiply(new PreciseNumber("426880")); + MutableReductionContext dummyContext = new MutableReductionContext(null, this, null); + NumberInterface C = FUNCTION_SQRT.apply(dummyContext, new PreciseNumber("10005")).multiply(new PreciseNumber("426880")); NumberInterface M = PreciseNumber.ONE; NumberInterface L = new PreciseNumber("13591409"); NumberInterface X = M; @@ -165,12 +167,12 @@ public class StandardPlugin extends Plugin { */ public static final NumberOperator OP_DIVIDE = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { - return params.length == 2 && params[1].compareTo(implementation.instanceForString(Integer.toString(0))) != 0; + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { + return params.length == 2 && params[1].compareTo(context.getInheritedNumberImplementation().instanceForString(Integer.toString(0))) != 0; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { return params[0].divide(params[1]); } }; @@ -180,14 +182,15 @@ public class StandardPlugin extends Plugin { public static final NumberOperator OP_FACTORIAL = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.UNARY_POSTFIX, 0) { //private HashMap, ArrayList> storedList = new HashMap, ArrayList>(); @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1 - && params[0].fractionalPart().compareTo(implementation.instanceForString("0")) == 0 + && params[0].fractionalPart().compareTo(context.getInheritedNumberImplementation().instanceForString("0")) == 0 && params[0].signum() >= 0; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberImplementation implementation = context.getInheritedNumberImplementation(); if (params[0].signum() == 0) { return implementation.instanceForString("1"); } @@ -211,13 +214,14 @@ public class StandardPlugin extends Plugin { */ public static final NumberOperator OP_NPR = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 2 && params[0].fractionalPart().signum() == 0 && params[1].fractionalPart().signum() == 0; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberImplementation implementation = context.getInheritedNumberImplementation(); if (params[0].compareTo(params[1]) < 0 || params[0].signum() < 0 || (params[0].signum() == 0 && params[1].signum() != 0)) return implementation.instanceForString("0"); @@ -241,14 +245,14 @@ public class StandardPlugin extends Plugin { */ public static final NumberOperator OP_NCR = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 2 && params[0].fractionalPart().signum() == 0 && params[1].fractionalPart().signum() == 0; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return OP_NPR.apply(implementation, params).divide(OP_FACTORIAL.apply(implementation, params[1])); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return OP_NPR.apply(context, params).divide(OP_FACTORIAL.apply(context, params[1])); } }; /** @@ -256,13 +260,13 @@ public class StandardPlugin extends Plugin { */ public static final NumberFunction FUNCTION_ABS = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return params[0].multiply(implementation.instanceForString(Integer.toString(params[0].signum()))); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return params[0].multiply(context.getInheritedNumberImplementation().instanceForString(Integer.toString(params[0].signum()))); } }; /** @@ -270,16 +274,17 @@ public class StandardPlugin extends Plugin { */ public static final NumberFunction FUNCTION_LN = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { - return params.length == 1 && params[0].compareTo(implementation.instanceForString("0")) > 0; + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { + return params.length == 1 && params[0].compareTo(context.getInheritedNumberImplementation().instanceForString("0")) > 0; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberImplementation implementation = context.getInheritedNumberImplementation(); NumberInterface param = params[0]; NumberInterface one = implementation.instanceForString("1"); int powersOf2 = 0; - while (FUNCTION_ABS.apply(implementation, param.subtract(one)).compareTo(implementation.instanceForString(".1")) >= 0) { + while (FUNCTION_ABS.apply(context, param.subtract(one)).compareTo(implementation.instanceForString(".1")) >= 0) { if (param.subtract(one).signum() == 1) { param = param.divide(implementation.instanceForString("2")); powersOf2++; @@ -296,7 +301,7 @@ public class StandardPlugin extends Plugin { } } } - return getLog2(implementation, param).multiply(implementation.instanceForString(Integer.toString(powersOf2))).add(getLogPartialSum(implementation, param)); + return getLog2(context.getInheritedNumberImplementation(), param).multiply(implementation.instanceForString(Integer.toString(powersOf2))).add(getLogPartialSum(context, param)); } /** @@ -305,13 +310,13 @@ public class StandardPlugin extends Plugin { * @param x value at which the series is evaluated. 0 < x < 2. (x=2 is convergent but impractical.) * @return the partial sum. */ - private NumberInterface getLogPartialSum(NumberImplementation implementation, NumberInterface x) { - + private NumberInterface getLogPartialSum(MutableReductionContext context, NumberInterface x) { + NumberImplementation implementation = context.getInheritedNumberImplementation(); NumberInterface maxError = x.getMaxError(); x = x.subtract(implementation.instanceForString("1")); //Terms used are for log(x+1). NumberInterface currentNumerator = x, currentTerm = x, sum = x; int n = 1; - while (FUNCTION_ABS.apply(implementation, currentTerm).compareTo(maxError) > 0) { + while (FUNCTION_ABS.apply(context, currentTerm).compareTo(maxError) > 0) { n++; currentNumerator = currentNumerator.multiply(x).negate(); currentTerm = currentNumerator.divide(implementation.instanceForString(Integer.toString(n))); @@ -350,13 +355,13 @@ public class StandardPlugin extends Plugin { */ public static final NumberFunction FUNCTION_RAND_INT = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return implementation.instanceForString(Long.toString(Math.round(Math.random() * params[0].floor().intValue()))); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return context.getInheritedNumberImplementation().instanceForString(Long.toString(Math.round(Math.random() * params[0].floor().intValue()))); } }; /** @@ -364,8 +369,8 @@ public class StandardPlugin extends Plugin { */ public static final NumberOperator OP_CARET = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { - NumberInterface zero = implementation.instanceForString("0"); + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { + NumberInterface zero = context.getInheritedNumberImplementation().instanceForString("0"); return params.length == 2 && !(params[0].compareTo(zero) == 0 && params[1].compareTo(zero) == 0) @@ -373,7 +378,8 @@ public class StandardPlugin extends Plugin { } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberImplementation implementation = context.getInheritedNumberImplementation(); NumberInterface zero = implementation.instanceForString("0"); if (params[0].compareTo(zero) == 0) return zero; @@ -381,12 +387,12 @@ public class StandardPlugin extends Plugin { return implementation.instanceForString("1"); //Detect integer bases: if (params[0].fractionalPart().compareTo(implementation.instanceForString("0")) == 0 - && FUNCTION_ABS.apply(implementation, params[1]).compareTo(implementation.instanceForString(Integer.toString(Integer.MAX_VALUE))) < 0 - && FUNCTION_ABS.apply(implementation, params[1]).compareTo(implementation.instanceForString("1")) >= 0) { + && FUNCTION_ABS.apply(context, params[1]).compareTo(implementation.instanceForString(Integer.toString(Integer.MAX_VALUE))) < 0 + && FUNCTION_ABS.apply(context, params[1]).compareTo(implementation.instanceForString("1")) >= 0) { NumberInterface[] newParams = {params[0], params[1].fractionalPart()}; - return params[0].intPow(params[1].floor().intValue()).multiply(applyInternal(implementation, newParams)); + return params[0].intPow(params[1].floor().intValue()).multiply(applyInternal(context, newParams)); } - return FUNCTION_EXP.apply(implementation, FUNCTION_LN.apply(implementation, FUNCTION_ABS.apply(implementation, params[0])).multiply(params[1])); + return FUNCTION_EXP.apply(context, FUNCTION_LN.apply(context, FUNCTION_ABS.apply(context, params[0])).multiply(params[1])); } }; /** @@ -394,13 +400,13 @@ public class StandardPlugin extends Plugin { */ public static final NumberFunction FUNCTION_SQRT = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return OP_CARET.apply(implementation, params[0], implementation.instanceForString(".5")); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return OP_CARET.apply(context, params[0], context.getInheritedNumberImplementation().instanceForString(".5")); } }; private static final HashMap> FACTORIAL_LISTS = new HashMap<>(); @@ -409,17 +415,18 @@ public class StandardPlugin extends Plugin { */ public static final NumberFunction FUNCTION_EXP = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberImplementation implementation = context.getInheritedNumberImplementation(); NumberInterface maxError = params[0].getMaxError(); int n = 0; if (params[0].signum() < 0) { NumberInterface[] negatedParams = {params[0].negate()}; - return implementation.instanceForString("1").divide(applyInternal(implementation, negatedParams)); + return implementation.instanceForString("1").divide(applyInternal(context, negatedParams)); } else { //We need n such that x^(n+1) * 3^ceil(x) <= maxError * (n+1)!. //right and left refer to lhs and rhs in the above inequality. @@ -446,15 +453,16 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionSin = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberImplementation implementation = context.getInheritedNumberImplementation(); NumberInterface pi = piFor(params[0].getClass()); NumberInterface twoPi = pi.multiply(implementation.instanceForString("2")); - NumberInterface theta = getSmallAngle(implementation, params[0], pi); + NumberInterface theta = getSmallAngle(context, params[0], pi); //System.out.println(theta); if (theta.compareTo(pi.multiply(implementation.instanceForString("1.5"))) >= 0) { theta = theta.subtract(twoPi); @@ -462,7 +470,7 @@ public class StandardPlugin extends Plugin { theta = pi.subtract(theta); } //System.out.println(theta); - return sinTaylor(implementation, theta); + return sinTaylor(context, theta); } }; /** @@ -470,13 +478,13 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionCos = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return functionSin.apply(implementation, piFor(params[0].getClass()).divide(implementation.instanceForString("2")) + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return functionSin.apply(context, piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2")) .subtract(params[0])); } }; @@ -485,13 +493,13 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionTan = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return functionSin.apply(implementation, params[0]).divide(functionCos.apply(implementation, params[0])); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return functionSin.apply(context, params[0]).divide(functionCos.apply(context, params[0])); } }; /** @@ -499,13 +507,13 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionSec = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return implementation.instanceForString("1").divide(functionCos.apply(implementation, params[0])); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return context.getInheritedNumberImplementation().instanceForString("1").divide(functionCos.apply(context, params[0])); } }; /** @@ -513,13 +521,13 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionCsc = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return implementation.instanceForString("1").divide(functionSin.apply(implementation, params[0])); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return context.getInheritedNumberImplementation().instanceForString("1").divide(functionSin.apply(context, params[0])); } }; /** @@ -527,13 +535,13 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionCot = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return functionCos.apply(implementation, params[0]).divide(functionSin.apply(implementation, params[0])); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return functionCos.apply(context, params[0]).divide(functionSin.apply(context, params[0])); } }; @@ -542,23 +550,24 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionArcsin = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1 - && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) <= 0; + && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) <= 0; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - if (FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString(".8")) >= 0) { - NumberInterface[] newParams = {FUNCTION_SQRT.apply(implementation, implementation.instanceForString("1").subtract(params[0].multiply(params[0])))}; + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberImplementation implementation = context.getInheritedNumberImplementation(); + if (FUNCTION_ABS.apply(context, params[0]).compareTo(implementation.instanceForString(".8")) >= 0) { + NumberInterface[] newParams = {FUNCTION_SQRT.apply(context, implementation.instanceForString("1").subtract(params[0].multiply(params[0])))}; return piFor(params[0].getClass()).divide(implementation.instanceForString("2")) - .subtract(applyInternal(implementation, newParams)).multiply(implementation.instanceForString(Integer.toString(params[0].signum()))); + .subtract(applyInternal(context, newParams)).multiply(implementation.instanceForString(Integer.toString(params[0].signum()))); } NumberInterface currentTerm = params[0], sum = currentTerm, multiplier = currentTerm.multiply(currentTerm), summandBound = sum.getMaxError().multiply(implementation.instanceForString("1").subtract(multiplier)), power = currentTerm, coefficient = implementation.instanceForString("1"); int exponent = 1; - while (FUNCTION_ABS.apply(implementation, currentTerm).compareTo(summandBound) > 0) { + while (FUNCTION_ABS.apply(context, currentTerm).compareTo(summandBound) > 0) { exponent += 2; power = power.multiply(multiplier); coefficient = coefficient.multiply(implementation.instanceForString(Integer.toString(exponent - 2))) @@ -575,14 +584,14 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionArccos = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { - return params.length == 1 && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) <= 0; + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { + return params.length == 1 && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) <= 0; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return piFor(params[0].getClass()).divide(implementation.instanceForString("2")) - .subtract(functionArcsin.apply(implementation, params)); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2")) + .subtract(functionArcsin.apply(context, params)); } }; @@ -591,14 +600,14 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionArccsc = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { - return params.length == 1 && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) >= 0; + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { + return params.length == 1 && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) >= 0; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - NumberInterface[] reciprocalParamArr = {implementation.instanceForString("1").divide(params[0])}; - return functionArcsin.apply(implementation, reciprocalParamArr); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberInterface[] reciprocalParamArr = {context.getInheritedNumberImplementation().instanceForString("1").divide(params[0])}; + return functionArcsin.apply(context, reciprocalParamArr); } }; @@ -607,14 +616,14 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionArcsec = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { - return params.length == 1 && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) >= 0; + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { + return params.length == 1 && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) >= 0; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - NumberInterface[] reciprocalParamArr = {implementation.instanceForString("1").divide(params[0])}; - return functionArccos.apply(implementation, reciprocalParamArr); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberInterface[] reciprocalParamArr = {context.getInheritedNumberImplementation().instanceForString("1").divide(params[0])}; + return functionArccos.apply(context, reciprocalParamArr); } }; @@ -623,20 +632,21 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionArctan = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + NumberImplementation implementation = context.getInheritedNumberImplementation(); if (params[0].signum() == -1) { NumberInterface[] negatedParams = {params[0].negate()}; - return applyInternal(implementation, negatedParams).negate(); + return applyInternal(context, negatedParams).negate(); } if (params[0].compareTo(implementation.instanceForString("1")) > 0) { NumberInterface[] reciprocalParams = {implementation.instanceForString("1").divide(params[0])}; return piFor(params[0].getClass()).divide(implementation.instanceForString("2")) - .subtract(applyInternal(implementation, reciprocalParams)); + .subtract(applyInternal(context, reciprocalParams)); } if (params[0].compareTo(implementation.instanceForString("1")) == 0) { return piFor(params[0].getClass()).divide(implementation.instanceForString("4")); @@ -644,12 +654,12 @@ public class StandardPlugin extends Plugin { if (params[0].compareTo(implementation.instanceForString(".9")) >= 0) { NumberInterface[] newParams = {params[0].multiply(implementation.instanceForString("2")) .divide(implementation.instanceForString("1").subtract(params[0].multiply(params[0])))}; - return applyInternal(implementation, newParams).divide(implementation.instanceForString("2")); + return applyInternal(context, newParams).divide(implementation.instanceForString("2")); } NumberInterface currentPower = params[0], currentTerm = currentPower, sum = currentTerm, maxError = params[0].getMaxError(), multiplier = currentPower.multiply(currentPower).negate(); int n = 1; - while (FUNCTION_ABS.apply(implementation, currentTerm).compareTo(maxError) > 0) { + while (FUNCTION_ABS.apply(context, currentTerm).compareTo(maxError) > 0) { n += 2; currentPower = currentPower.multiply(multiplier); currentTerm = currentPower.divide(implementation.instanceForString(Integer.toString(n))); @@ -664,14 +674,14 @@ public class StandardPlugin extends Plugin { */ public final NumberFunction functionArccot = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 1; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return piFor(params[0].getClass()).divide(implementation.instanceForString("2")) - .subtract(functionArctan.apply(implementation, params)); + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2")) + .subtract(functionArctan.apply(context, params)); } }; @@ -709,16 +719,16 @@ public class StandardPlugin extends Plugin { * @param x where the series is evaluated. * @return the value of the series */ - private static NumberInterface sinTaylor(NumberImplementation implementation, NumberInterface x) { + private static NumberInterface sinTaylor(MutableReductionContext context, NumberInterface x) { NumberInterface power = x, multiplier = x.multiply(x).negate(), currentTerm = x, sum = x; NumberInterface maxError = x.getMaxError(); int n = 1; do { n += 2; power = power.multiply(multiplier); - currentTerm = power.divide(factorial(implementation, n)); + currentTerm = power.divide(factorial(context.getInheritedNumberImplementation(), n)); sum = sum.add(currentTerm); - } while (FUNCTION_ABS.apply(implementation, currentTerm).compareTo(maxError) > 0); + } while (FUNCTION_ABS.apply(context, currentTerm).compareTo(maxError) > 0); return sum; } @@ -728,10 +738,10 @@ public class StandardPlugin extends Plugin { * @param phi an angle (in radians). * @return theta in [0, 2pi) that differs from phi by a multiple of 2pi. */ - private static NumberInterface getSmallAngle(NumberImplementation implementation, NumberInterface phi, NumberInterface pi) { - NumberInterface twoPi = pi.multiply(implementation.instanceForString("2")); - NumberInterface theta = FUNCTION_ABS.apply(implementation, phi).subtract(twoPi - .multiply(FUNCTION_ABS.apply(implementation, phi).divide(twoPi).floor())); //Now theta is in [0, 2pi). + private static NumberInterface getSmallAngle(MutableReductionContext context, NumberInterface phi, NumberInterface pi) { + NumberInterface twoPi = pi.multiply(context.getInheritedNumberImplementation().instanceForString("2")); + NumberInterface theta = FUNCTION_ABS.apply(context, phi).subtract(twoPi + .multiply(FUNCTION_ABS.apply(context, phi).divide(twoPi).floor())); //Now theta is in [0, 2pi). if (phi.signum() < 0) { theta = twoPi.subtract(theta); } diff --git a/core/src/main/kotlin/org/nwapw/abacus/Abacus.kt b/core/src/main/kotlin/org/nwapw/abacus/Abacus.kt index c191133..d123ee4 100644 --- a/core/src/main/kotlin/org/nwapw/abacus/Abacus.kt +++ b/core/src/main/kotlin/org/nwapw/abacus/Abacus.kt @@ -84,6 +84,6 @@ class Abacus(val configuration: Configuration) { * @return the resulting number, or null of the reduction failed. */ fun evaluateTree(tree: TreeNode): NumberInterface? = - tree.reduce(NumberReducer(this, context.mutableSubInstance())) + tree.reduce(NumberReducer(this, context)) } \ No newline at end of file diff --git a/core/src/main/kotlin/org/nwapw/abacus/function/TreeValueFunction.kt b/core/src/main/kotlin/org/nwapw/abacus/function/TreeValueFunction.kt index 7b31d92..198b271 100644 --- a/core/src/main/kotlin/org/nwapw/abacus/function/TreeValueFunction.kt +++ b/core/src/main/kotlin/org/nwapw/abacus/function/TreeValueFunction.kt @@ -1,6 +1,6 @@ package org.nwapw.abacus.function -import org.nwapw.abacus.function.applicable.ReducerApplicable +import org.nwapw.abacus.function.applicable.Applicable import org.nwapw.abacus.number.NumberInterface import org.nwapw.abacus.tree.TreeNode @@ -10,4 +10,4 @@ import org.nwapw.abacus.tree.TreeNode * A function that operates on parse tree nodes instead of on already simplified numbers. * Despite this, it returns a number, not a tree. */ -abstract class TreeValueFunction : ReducerApplicable +abstract class TreeValueFunction : Applicable diff --git a/core/src/main/kotlin/org/nwapw/abacus/function/TreeValueOperator.kt b/core/src/main/kotlin/org/nwapw/abacus/function/TreeValueOperator.kt index 7c4eea7..92b208f 100644 --- a/core/src/main/kotlin/org/nwapw/abacus/function/TreeValueOperator.kt +++ b/core/src/main/kotlin/org/nwapw/abacus/function/TreeValueOperator.kt @@ -1,6 +1,6 @@ package org.nwapw.abacus.function -import org.nwapw.abacus.function.applicable.ReducerApplicable +import org.nwapw.abacus.function.applicable.Applicable import org.nwapw.abacus.number.NumberInterface import org.nwapw.abacus.tree.TreeNode @@ -15,4 +15,4 @@ import org.nwapw.abacus.tree.TreeNode abstract class TreeValueOperator(associativity: OperatorAssociativity, type: OperatorType, precedence: Int) : Operator(associativity, type, precedence), - ReducerApplicable \ No newline at end of file + Applicable \ No newline at end of file diff --git a/core/src/main/kotlin/org/nwapw/abacus/function/applicable/Applicable.kt b/core/src/main/kotlin/org/nwapw/abacus/function/applicable/Applicable.kt index ed8bb91..3aff900 100644 --- a/core/src/main/kotlin/org/nwapw/abacus/function/applicable/Applicable.kt +++ b/core/src/main/kotlin/org/nwapw/abacus/function/applicable/Applicable.kt @@ -1,7 +1,7 @@ package org.nwapw.abacus.function.applicable +import org.nwapw.abacus.context.MutableReductionContext import org.nwapw.abacus.function.DomainException -import org.nwapw.abacus.plugin.NumberImplementation /** * A class that can be applied to arguments. @@ -18,7 +18,7 @@ interface Applicable { * @param params the parameter array to verify for compatibility. * @return whether the array can be used with applyInternal. */ - fun matchesParams(implementation: NumberImplementation, params: Array): Boolean + fun matchesParams(context: MutableReductionContext, params: Array): Boolean /** * Applies the applicable object to the given parameters, @@ -26,7 +26,7 @@ interface Applicable { * @param params the parameters to apply to. * @return the result of the application. */ - fun applyInternal(implementation: NumberImplementation, params: Array): O + fun applyInternal(context: MutableReductionContext, params: Array): O /** * If the parameters can be used with this applicable, returns @@ -35,9 +35,9 @@ interface Applicable { * @param params the parameters to apply to. * @return the result of the operation, or null if parameters do not match. */ - fun apply(implementation: NumberImplementation, vararg params: T): O { - if (!matchesParams(implementation, params)) throw DomainException() - return applyInternal(implementation, params) + fun apply(context: MutableReductionContext, vararg params: T): O { + if (!matchesParams(context, params)) throw DomainException() + return applyInternal(context, params) } } \ No newline at end of file diff --git a/core/src/main/kotlin/org/nwapw/abacus/function/applicable/ReducerApplicable.kt b/core/src/main/kotlin/org/nwapw/abacus/function/applicable/ReducerApplicable.kt deleted file mode 100644 index 54340a4..0000000 --- a/core/src/main/kotlin/org/nwapw/abacus/function/applicable/ReducerApplicable.kt +++ /dev/null @@ -1,45 +0,0 @@ -package org.nwapw.abacus.function.applicable - -import org.nwapw.abacus.function.DomainException -import org.nwapw.abacus.plugin.NumberImplementation -import org.nwapw.abacus.tree.Reducer - -/** - * Applicable that requires a reducer. - * - * ReducerApplicable slightly more specific Applicable that requires a reducer - * to be passed to it along with the parameters. - * @param the type of the input arguments. - * @param the return type of the application. - * @param the required type of the reducer. - */ -interface ReducerApplicable { - - /** - * Checks if this applicable can be applied to the - * given parameters. - * @param params the parameters to check. - */ - fun matchesParams(implementation: NumberImplementation, params: Array): Boolean - - /** - * Applies this applicable to the given arguments, and reducer. - * @param reducer the reducer to use in the application. - * @param params the arguments to apply to. - * @return the result of the application. - */ - fun applyWithReducerInternal(implementation: NumberImplementation, reducer: Reducer, params: Array): O - - /** - * Applies this applicable to the given arguments, and reducer, - * if the arguments and reducer are compatible with this applicable. - * @param reducer the reducer to use in the application. - * @param params the arguments to apply to. - * @return the result of the application, or null if the arguments are incompatible. - */ - fun applyWithReducer(implementation: NumberImplementation, reducer: Reducer, vararg params: T): O { - if (!matchesParams(implementation, params)) throw DomainException() - return applyWithReducerInternal(implementation, reducer, params) - } - -} \ No newline at end of file diff --git a/core/src/main/kotlin/org/nwapw/abacus/tree/NumberReducer.kt b/core/src/main/kotlin/org/nwapw/abacus/tree/NumberReducer.kt index 4fc658e..bc62039 100644 --- a/core/src/main/kotlin/org/nwapw/abacus/tree/NumberReducer.kt +++ b/core/src/main/kotlin/org/nwapw/abacus/tree/NumberReducer.kt @@ -2,10 +2,17 @@ package org.nwapw.abacus.tree import org.nwapw.abacus.Abacus import org.nwapw.abacus.context.MutableReductionContext +import org.nwapw.abacus.context.ReductionContext import org.nwapw.abacus.function.NumberFunction import org.nwapw.abacus.number.NumberInterface -class NumberReducer(val abacus: Abacus, val context: MutableReductionContext) : Reducer { +class NumberReducer(val abacus: Abacus, context: ReductionContext) : Reducer { + + val context = context.mutableSubInstance() + + init { + this.context.reducer = this + } override fun reduceNode(treeNode: TreeNode, vararg children: Any): NumberInterface? { val promotionManager = abacus.promotionManager @@ -22,33 +29,34 @@ class NumberReducer(val abacus: Abacus, val context: MutableReductionContext) : } is NumberUnaryNode -> { val child = children[0] as NumberInterface + context.numberImplementation = abacus.pluginManager.interfaceImplementationFor(child.javaClass) abacus.pluginManager.operatorFor(treeNode.operation) - .apply(abacus.pluginManager.interfaceImplementationFor(child.javaClass), child) + .apply(context, child) } is NumberBinaryNode -> { val left = children[0] as NumberInterface val right = children[1] as NumberInterface val promotionResult = promotionManager.promote(left, right) ?: return null - abacus.pluginManager.operatorFor(treeNode.operation).apply(promotionResult.promotedTo, *promotionResult.items) + context.numberImplementation = promotionResult.promotedTo + abacus.pluginManager.operatorFor(treeNode.operation).apply(context, *promotionResult.items) } is FunctionNode -> { val promotionResult = promotionManager .promote(*children.map { it as NumberInterface }.toTypedArray()) ?: return null - abacus.pluginManager.functionFor(treeNode.callTo).apply(promotionResult.promotedTo, *promotionResult.items) + context.numberImplementation = promotionResult.promotedTo + abacus.pluginManager.functionFor(treeNode.callTo).apply(context, *promotionResult.items) } is TreeValueUnaryNode -> { abacus.pluginManager.treeValueOperatorFor(treeNode.operation) - .applyWithReducer(context.inheritedNumberImplementation!!, this, children[0] as TreeNode) + .apply(context, treeNode.applyTo ?: return null) } is TreeValueBinaryNode -> { abacus.pluginManager.treeValueOperatorFor(treeNode.operation) - .applyWithReducer(context.inheritedNumberImplementation!!, this, - children[0] as TreeNode, children[1] as TreeNode) + .apply(context, treeNode.left ?: return null, treeNode.right ?: return null) } is TreeValueFunctionNode -> { abacus.pluginManager.treeValueFunctionFor(treeNode.callTo) - .applyWithReducer(context.inheritedNumberImplementation!!, this, - *children.map { it as TreeNode }.toTypedArray()) + .apply(context, *treeNode.children.toTypedArray()) } else -> null } diff --git a/core/src/test/java/org/nwapw/abacus/tests/TokenizerTests.java b/core/src/test/java/org/nwapw/abacus/tests/TokenizerTests.java index 660be2f..5ef7f2f 100644 --- a/core/src/test/java/org/nwapw/abacus/tests/TokenizerTests.java +++ b/core/src/test/java/org/nwapw/abacus/tests/TokenizerTests.java @@ -1,10 +1,12 @@ package org.nwapw.abacus.tests; +import org.jetbrains.annotations.NotNull; import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; import org.nwapw.abacus.Abacus; import org.nwapw.abacus.config.Configuration; +import org.nwapw.abacus.context.MutableReductionContext; import org.nwapw.abacus.function.*; import org.nwapw.abacus.lexing.pattern.Match; import org.nwapw.abacus.number.NumberInterface; @@ -21,12 +23,12 @@ public class TokenizerTests { private static LexerTokenizer lexerTokenizer = new LexerTokenizer(); private static NumberFunction subtractFunction = new NumberFunction() { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return params.length == 2; } @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { return params[0].subtract(params[1]); } }; @@ -37,26 +39,26 @@ public class TokenizerTests { 0) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return true; } - @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return subtractFunction.apply(implementation, params); + @Override + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return subtractFunction.apply(context, params); } }); registerOperator("-", new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) { @Override - public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) { + public boolean matchesParams(MutableReductionContext context, NumberInterface[] params) { return true; } - @Override - public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) { - return subtractFunction.apply(implementation, params); + @Override + public NumberInterface applyInternal(MutableReductionContext context, NumberInterface[] params) { + return subtractFunction.apply(context, params); } }); registerFunction("subtract", subtractFunction);