diff --git a/src/main/java/org/nwapw/abacus/Abacus.java b/src/main/java/org/nwapw/abacus/Abacus.java index 649bb1a..0eb84d1 100644 --- a/src/main/java/org/nwapw/abacus/Abacus.java +++ b/src/main/java/org/nwapw/abacus/Abacus.java @@ -2,12 +2,12 @@ package org.nwapw.abacus; import org.nwapw.abacus.config.Configuration; import org.nwapw.abacus.fx.AbacusApplication; -import org.nwapw.abacus.number.NaiveNumber; import org.nwapw.abacus.number.NumberInterface; import org.nwapw.abacus.parsing.LexerTokenizer; import org.nwapw.abacus.parsing.ShuntingYardParser; import org.nwapw.abacus.parsing.TreeBuilder; import org.nwapw.abacus.plugin.ClassFinder; +import org.nwapw.abacus.plugin.NumberImplementation; import org.nwapw.abacus.plugin.PluginManager; import org.nwapw.abacus.plugin.StandardPlugin; import org.nwapw.abacus.tree.NumberReducer; @@ -15,7 +15,6 @@ import org.nwapw.abacus.tree.TreeNode; import java.io.File; import java.io.IOException; -import java.lang.reflect.InvocationTargetException; /** * The main calculator class. This is responsible @@ -24,10 +23,7 @@ import java.lang.reflect.InvocationTargetException; */ public class Abacus { - /** - * The default implementation to use for the number representation. - */ - public static final Class DEFAULT_NUMBER = NaiveNumber.class; + public static final NumberImplementation DEFAULT_IMPLEMENTATION = StandardPlugin.IMPLEMENTATION_NAIVE; /** * The file used for saving and loading configuration. */ @@ -147,15 +143,10 @@ public class Abacus { * @return the resulting number. */ public NumberInterface numberFromString(String numberString) { - Class toInstantiate = - pluginManager.numberFor(configuration.getNumberImplementation()); - if (toInstantiate == null) toInstantiate = DEFAULT_NUMBER; + NumberImplementation toInstantiate = + pluginManager.numberImplementationFor(configuration.getNumberImplementation()); + if (toInstantiate == null) toInstantiate = DEFAULT_IMPLEMENTATION; - try { - return toInstantiate.getConstructor(String.class).newInstance(numberString); - } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) { - e.printStackTrace(); - } - return null; + return toInstantiate.instanceForString(numberString); } } diff --git a/src/main/java/org/nwapw/abacus/function/Function.java b/src/main/java/org/nwapw/abacus/function/Function.java index 62a0e7d..bd5af72 100755 --- a/src/main/java/org/nwapw/abacus/function/Function.java +++ b/src/main/java/org/nwapw/abacus/function/Function.java @@ -1,10 +1,6 @@ package org.nwapw.abacus.function; -import org.nwapw.abacus.number.NaiveNumber; import org.nwapw.abacus.number.NumberInterface; -import org.nwapw.abacus.number.PreciseNumber; - -import java.util.HashMap; /** * A function that operates on one or more @@ -12,15 +8,6 @@ import java.util.HashMap; */ public abstract class Function { - /** - * A map to correctly promote different number implementations to each other. - */ - private static final HashMap, Integer> priorityMap = - new HashMap, Integer>() {{ - put(NaiveNumber.class, 0); - put(PreciseNumber.class, 1); - }}; - /** * Checks whether the given params will work for the given function. * diff --git a/src/main/java/org/nwapw/abacus/fx/AbacusController.java b/src/main/java/org/nwapw/abacus/fx/AbacusController.java index aae51df..a924af9 100644 --- a/src/main/java/org/nwapw/abacus/fx/AbacusController.java +++ b/src/main/java/org/nwapw/abacus/fx/AbacusController.java @@ -220,7 +220,7 @@ public class AbacusController implements PluginListener { public void onLoad(PluginManager manager) { Configuration configuration = abacus.getConfiguration(); Set disabledPlugins = configuration.getDisabledPlugins(); - numberImplementationOptions.addAll(abacus.getPluginManager().getAllNumbers()); + numberImplementationOptions.addAll(abacus.getPluginManager().getAllNumberImplementations()); String actualImplementation = configuration.getNumberImplementation(); String toSelect = (numberImplementationOptions.contains(actualImplementation)) ? actualImplementation : ""; numberImplementationBox.getSelectionModel().select(toSelect); diff --git a/src/main/java/org/nwapw/abacus/number/NaiveNumber.java b/src/main/java/org/nwapw/abacus/number/NaiveNumber.java index 8c23b6b..b32e2fa 100755 --- a/src/main/java/org/nwapw/abacus/number/NaiveNumber.java +++ b/src/main/java/org/nwapw/abacus/number/NaiveNumber.java @@ -94,8 +94,23 @@ public class NaiveNumber implements NumberInterface { } @Override - public int ceiling() { - return (int) Math.ceil(value); + public NumberInterface ceiling() { + return new NaiveNumber(Math.ceil(value)); + } + + @Override + public NumberInterface floor() { + return new NaiveNumber(Math.floor(value)); + } + + @Override + public NumberInterface fractionalPart() { + return new NaiveNumber(value - Math.floor(value)); + } + + @Override + public int intValue() { + return (int)value; } @Override diff --git a/src/main/java/org/nwapw/abacus/number/NumberInterface.java b/src/main/java/org/nwapw/abacus/number/NumberInterface.java index 34d1cfd..dad9274 100755 --- a/src/main/java/org/nwapw/abacus/number/NumberInterface.java +++ b/src/main/java/org/nwapw/abacus/number/NumberInterface.java @@ -83,7 +83,26 @@ public interface NumberInterface { * Returns the least integer greater than or equal to the number. * @return the least integer >= the number, if int can hold the value. */ - int ceiling(); + NumberInterface ceiling(); + + /** + * Return the greatest integer less than or equal to the number. + * @return the greatest int >= the number, if int can hold the value. + */ + NumberInterface floor(); + + /** + * Returns the fractional part of the number. + * @return the fractional part of the number. + */ + NumberInterface fractionalPart(); + + /** + * Returns the integer representation of this number, discarding any fractional part, + * if int can hold the value. + * @return + */ + int intValue(); /** * Promotes this class to another number class. diff --git a/src/main/java/org/nwapw/abacus/number/PreciseNumber.java b/src/main/java/org/nwapw/abacus/number/PreciseNumber.java index 840b075..458815f 100755 --- a/src/main/java/org/nwapw/abacus/number/PreciseNumber.java +++ b/src/main/java/org/nwapw/abacus/number/PreciseNumber.java @@ -12,15 +12,15 @@ public class PreciseNumber implements NumberInterface { /** * The number one. */ - static final PreciseNumber ONE = new PreciseNumber(BigDecimal.ONE); + public static final PreciseNumber ONE = new PreciseNumber(BigDecimal.ONE); /** * The number zero. */ - static final PreciseNumber ZERO = new PreciseNumber(BigDecimal.ZERO); + public static final PreciseNumber ZERO = new PreciseNumber(BigDecimal.ZERO); /** * The number ten. */ - static final PreciseNumber TEN = new PreciseNumber(BigDecimal.TEN); + public static final PreciseNumber TEN = new PreciseNumber(BigDecimal.TEN); /** * The value of the PreciseNumber. @@ -99,8 +99,38 @@ public class PreciseNumber implements NumberInterface { } @Override - public int ceiling() { - return (int) Math.ceil(value.doubleValue()); + public NumberInterface ceiling() { + String str = value.toPlainString(); + int decimalIndex = str.indexOf('.'); + if(decimalIndex != -1){ + return this.floor().add(ONE); + } + return this; + } + + @Override + public NumberInterface floor() { + String str = value.toPlainString(); + int decimalIndex = str.indexOf('.'); + if(decimalIndex != -1){ + return new PreciseNumber(str.substring(0, decimalIndex)); + } + return this; + } + + @Override + public NumberInterface fractionalPart() { + String str = value.toPlainString(); + int decimalIndex = str.indexOf('.'); + if(decimalIndex != -1){ + return new PreciseNumber(str.substring(decimalIndex + 1)); + } + return ZERO; + } + + @Override + public int intValue() { + return value.intValue(); } @Override diff --git a/src/main/java/org/nwapw/abacus/plugin/NumberImplementation.java b/src/main/java/org/nwapw/abacus/plugin/NumberImplementation.java new file mode 100644 index 0000000..66e2dd2 --- /dev/null +++ b/src/main/java/org/nwapw/abacus/plugin/NumberImplementation.java @@ -0,0 +1,75 @@ +package org.nwapw.abacus.plugin; + +import org.nwapw.abacus.number.NumberInterface; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.Function; + +/** + * A class that holds data about a number implementation. + */ +public abstract class NumberImplementation { + + /** + * The list of paths through which this implementation can be promoted. + */ + protected Map, Function> promotionPaths; + /** + * The implementation class for this implementation. + */ + private Class implementation; + /** + * The priority of converting into this number implementation. + */ + private int priority; + + /** + * Creates a new number implementation with the given data. + * @param implementation the implementation class. + * @param priority the priority, higher -> more likely to be converted into. + */ + public NumberImplementation(Class implementation, int priority){ + this.implementation = implementation; + this.priority = priority; + promotionPaths = new HashMap<>(); + } + + /** + * Gets the list of all promotion paths this implementation can take. + * @return the map of documentation paths. + */ + public final Map, Function> getPromotionPaths(){ + return promotionPaths; + } + + /** + * Gets the implementation class used by this implementation. + * @return the implementation class. + */ + public final Class getImplementation(){ + return implementation; + } + + /** + * Gets the priority of this number implementation. + * @return the priority. + */ + public final int getPriority(){ + return priority; + } + + /** + * Abstract function to create a new instance from a string. + * @param string the string to create a number from. + * @return the resulting number. + */ + public abstract NumberInterface instanceForString(String string); + + /** + * Get the instance of pi with the given implementation. + * @return pi + */ + public abstract NumberInterface instanceForPi(); + +} diff --git a/src/main/java/org/nwapw/abacus/plugin/Plugin.java b/src/main/java/org/nwapw/abacus/plugin/Plugin.java index 62f6ecf..3a0ed31 100644 --- a/src/main/java/org/nwapw/abacus/plugin/Plugin.java +++ b/src/main/java/org/nwapw/abacus/plugin/Plugin.java @@ -26,9 +26,9 @@ public abstract class Plugin { */ private Map operators; /** - * A hash map of operators mapped to their string names. + * The map of the number implementations this plugin provides. */ - private Map> numbers; + private Map numberImplementations; /** * The plugin manager in which to search for functions * not inside this package, @@ -51,7 +51,7 @@ public abstract class Plugin { this.manager = manager; functions = new HashMap<>(); operators = new HashMap<>(); - numbers = new HashMap<>(); + numberImplementations = new HashMap<>(); enabled = false; } @@ -74,12 +74,12 @@ public abstract class Plugin { } /** - * Gets the list of all numbers provided by this plugin. + * Gets the list of number implementations provided by this plugin. * - * @return the list of registered numbers. + * @return the list of registered number implementations. */ - public final Set providedNumbers() { - return numbers.keySet(); + public final Set providedNumberImplementations(){ + return numberImplementations.keySet(); } /** @@ -103,13 +103,13 @@ public abstract class Plugin { } /** - * Gets the class under the given name. + * Gets the number implementation under the given name. * - * @param numberName the name of the class. - * @return the class, or null if the plugin doesn't provide it. + * @param name the name of the number implementation to look up. + * @return the number implementation associated with that name, or null if the plugin doesn't provide it. */ - public final Class getNumber(String numberName) { - return numbers.get(numberName); + public final NumberImplementation getNumberImplementation(String name){ + return numberImplementations.get(name); } /** @@ -158,16 +158,13 @@ public abstract class Plugin { } /** - * To be used in load(). Registers a number class - * with the plugin internally, which makes it possible - * for the user to select it as an "implementation" for the - * number that they would like to use. - * - * @param name the name to register it under. - * @param toRegister the class to register. + * To be used in load(). Registers a new number implementation with the plugin. + * This makes it accessible to the plugin manager. + * @param name the name of the implementation. + * @param implementation the actual implementation class to register. */ - protected final void registerNumber(String name, Class toRegister) { - numbers.put(name, toRegister); + protected final void registerNumberImplementation(String name, NumberImplementation implementation){ + numberImplementations.put(name, implementation); } /** @@ -194,6 +191,30 @@ public abstract class Plugin { return manager.operatorFor(name); } + /** + * Searches the PluginManager for the given number implementation + * name. This can be used by the plugins internally in order to find + * implementations that they do not provide. + * + * @param name the name for which to search. + * @return the resulting number implementation, or null if none was found. + */ + protected final NumberImplementation numberImplementationFor(String name){ + return manager.numberImplementationFor(name); + } + + /** + * Searches the plugin manager for a Pi value for the given number implementation. + * This is done so that number implementations with various degrees of precision + * can provide their own pi values, without losing said precision by + * promoting NaiveNumbers. + * @param forClass the class to which to find the pi instance. + * @return the pi value for the given class. + */ + protected final NumberInterface getPi(Class forClass){ + return manager.piFor(forClass); + } + /** * Abstract method to be overridden by plugin implementation, in which the plugins * are supposed to register the functions they provide and do any other diff --git a/src/main/java/org/nwapw/abacus/plugin/PluginManager.java b/src/main/java/org/nwapw/abacus/plugin/PluginManager.java index ab116dc..921b9dd 100644 --- a/src/main/java/org/nwapw/abacus/plugin/PluginManager.java +++ b/src/main/java/org/nwapw/abacus/plugin/PluginManager.java @@ -33,10 +33,19 @@ public class PluginManager { */ private Map cachedOperators; /** - * List of registered number implementations that have + * The list of number implementations that have * been cached, that is, found in a plugin and returned. */ - private Map> cachedNumbers; + private Map cachedNumberImplementations; + /** + * The list of number implementations that have been + * found by their implementation class. + */ + private Map, NumberImplementation> cachedInterfaceImplementations; + /** + * The pi values for each implementation class that have already been computer. + */ + private Map, NumberInterface> cachedPi; /** * List of all functions loaded by the plugins. */ @@ -46,9 +55,9 @@ public class PluginManager { */ private Set allOperators; /** - * List of all numbers loaded by the plugins. + * List of all the number implementations loaded by the plugins. */ - private Set allNumbers; + private Set allNumberImplementations; /** * The list of plugin listeners attached to this instance. */ @@ -68,10 +77,12 @@ public class PluginManager { plugins = new HashSet<>(); cachedFunctions = new HashMap<>(); cachedOperators = new HashMap<>(); - cachedNumbers = new HashMap<>(); + cachedNumberImplementations = new HashMap<>(); + cachedInterfaceImplementations = new HashMap<>(); + cachedPi = new HashMap<>(); allFunctions = new HashSet<>(); allOperators = new HashSet<>(); - allNumbers = new HashSet<>(); + allNumberImplementations = new HashSet<>(); listeners = new HashSet<>(); } @@ -87,12 +98,13 @@ public class PluginManager { * @param getFunction the function to get the T value under the given name * @param name the name to search for * @param the type of element being search + * @param the type of key that the cache is indexed by. * @return the retrieved element, or null if it was not found. */ - private static T searchCached(Collection plugins, Map cache, - java.util.function.Function> setFunction, - java.util.function.BiFunction getFunction, - String name) { + private static T searchCached(Collection plugins, Map cache, + java.util.function.Function> setFunction, + java.util.function.BiFunction getFunction, + K name) { if (cache.containsKey(name)) return cache.get(name); T loadedValue = null; @@ -128,13 +140,51 @@ public class PluginManager { } /** - * Gets a numer implementation under the given name. - * + * Gets the number implementation under the given name. * @param name the name of the implementation. - * @return the implementation class + * @return the implementation. */ - public Class numberFor(String name) { - return searchCached(plugins, cachedNumbers, Plugin::providedNumbers, Plugin::getNumber, name); + public NumberImplementation numberImplementationFor(String name){ + return searchCached(plugins, cachedNumberImplementations, Plugin::providedNumberImplementations, + Plugin::getNumberImplementation, name); + } + + /** + * Gets the number implementation for the given implementation class. + * @param name the class for which to find the implementation. + * @return the implementation. + */ + public NumberImplementation interfaceImplementationFor(Class name){ + if(cachedInterfaceImplementations.containsKey(name)) return cachedInterfaceImplementations.get(name); + NumberImplementation toReturn = null; + outside: + for(Plugin plugin : plugins){ + for(String implementationName : plugin.providedNumberImplementations()){ + NumberImplementation implementation = plugin.getNumberImplementation(implementationName); + if(implementation.getImplementation().equals(name)) { + toReturn = implementation; + break outside; + } + } + } + cachedInterfaceImplementations.put(name, toReturn); + return toReturn; + } + + /** + * Gets the mathematical constant pi for the given implementation class. + * @param forClass the class for which to find pi. + * @return pi + */ + public NumberInterface piFor(Class forClass){ + if(cachedPi.containsKey(forClass)) return cachedPi.get(forClass); + NumberImplementation implementation = interfaceImplementationFor(forClass); + NumberInterface generatedPi = null; + if(implementation != null){ + generatedPi = implementation.instanceForPi(); + } + cachedPi.put(forClass, generatedPi); + return generatedPi; } /** @@ -176,7 +226,7 @@ public class PluginManager { if(disabledPlugins.contains(plugin.getClass().getName())) continue; allFunctions.addAll(plugin.providedFunctions()); allOperators.addAll(plugin.providedOperators()); - allNumbers.addAll(plugin.providedNumbers()); + allNumberImplementations.addAll(plugin.providedNumberImplementations()); } listeners.forEach(e -> e.onLoad(this)); } @@ -193,10 +243,13 @@ public class PluginManager { } cachedFunctions.clear(); cachedOperators.clear(); - cachedNumbers.clear(); + cachedNumberImplementations.clear(); + cachedInterfaceImplementations.clear(); + cachedPi.clear(); allFunctions.clear(); allOperators.clear(); - allNumbers.clear(); + allNumberImplementations.clear(); + listeners.forEach(e -> e.onUnload(this)); } /** @@ -226,12 +279,12 @@ public class PluginManager { } /** - * Gets all the number implementations loaded by the Plugin Manager + * Gets all the number implementations loaded by the Plugin Manager. * - * @return the set of all implementations that were loaded + * @return the set of all implementations that were loaded. */ - public Set getAllNumbers() { - return allNumbers; + public Set getAllNumberImplementations(){ + return allNumberImplementations; } /** diff --git a/src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java b/src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java index 6cbc4e8..029c044 100755 --- a/src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java +++ b/src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java @@ -105,7 +105,9 @@ public class StandardPlugin extends Plugin { //private HashMap, ArrayList> storedList = new HashMap, ArrayList>(); @Override protected boolean matchesParams(NumberInterface[] params) { - return params.length == 1; + return params.length == 1 + && params[0].fractionalPart().compareTo(NaiveNumber.ZERO.promoteTo(params[0].getClass())) == 0 + && params[0].signum() >= 0; } @Override @@ -182,7 +184,7 @@ public class StandardPlugin extends Plugin { //right and left refer to lhs and rhs in the above inequality. NumberInterface sum = NaiveNumber.ONE.promoteTo(params[0].getClass()); NumberInterface nextNumerator = params[0]; - NumberInterface left = params[0].multiply((new NaiveNumber(3)).promoteTo(params[0].getClass()).intPow(params[0].ceiling())), right = maxError; + NumberInterface left = params[0].multiply((new NaiveNumber(3)).promoteTo(params[0].getClass()).intPow(params[0].ceiling().intValue())), right = maxError; do{ sum = sum.add(nextNumerator.divide(factorial(params[0].getClass(), n+1))); n++; @@ -290,6 +292,145 @@ public class StandardPlugin extends Plugin { } }; + /** + * The sine function (the argument is interpreted in radians). + */ + public final Function functionSin = new Function() { + @Override + protected boolean matchesParams(NumberInterface[] params) { + return params.length == 1; + } + + @Override + protected NumberInterface applyInternal(NumberInterface[] params) { + NumberInterface pi = getPi(params[0].getClass()); + NumberInterface twoPi = pi.multiply(new NaiveNumber(2).promoteTo(pi.getClass())); + NumberInterface theta = getSmallAngle(params[0], pi); + //System.out.println(theta); + if(theta.compareTo(pi.multiply(new NaiveNumber(1.5).promoteTo(twoPi.getClass()))) >= 0){ + theta = theta.subtract(twoPi); + } + else if(theta.compareTo(pi.divide(new NaiveNumber(2).promoteTo(pi.getClass()))) > 0){ + theta = pi.subtract(theta); + } + //System.out.println(theta); + return sinTaylor(theta); + } + }; + + public final Function functionCos = new Function() { + @Override + protected boolean matchesParams(NumberInterface[] params) { + return params.length == 1; + } + + @Override + protected NumberInterface applyInternal(NumberInterface[] params) { + return functionSin.apply(getPi(params[0].getClass()).divide(new NaiveNumber(2).promoteTo(params[0].getClass())) + .subtract(params[0])); + } + }; + + public final Function functionTan = new Function() { + @Override + protected boolean matchesParams(NumberInterface[] params) { + return params.length == 1; + } + + @Override + protected NumberInterface applyInternal(NumberInterface[] params) { + return functionSin.apply(params[0]).divide(functionCos.apply(params[0])); + } + }; + + public final Function functionSec = new Function() { + @Override + protected boolean matchesParams(NumberInterface[] params) { + return params.length == 1; + } + + @Override + protected NumberInterface applyInternal(NumberInterface[] params) { + return NaiveNumber.ONE.promoteTo(params[0].getClass()).divide(functionCos.apply(params[0])); + } + }; + + public final Function functionCsc = new Function() { + @Override + protected boolean matchesParams(NumberInterface[] params) { + return params.length == 1; + } + + @Override + protected NumberInterface applyInternal(NumberInterface[] params) { + return NaiveNumber.ONE.promoteTo(params[0].getClass()).divide(functionSin.apply(params[0])); + } + }; + + public final Function functionCot = new Function() { + @Override + protected boolean matchesParams(NumberInterface[] params) { + return params.length == 1; + } + + @Override + protected NumberInterface applyInternal(NumberInterface[] params) { + return functionCos.apply(params[0]).divide(functionCos.apply(params[0])); + } + }; + + /** + * The implementation for double-based naive numbers. + */ + public static final NumberImplementation IMPLEMENTATION_NAIVE = new NumberImplementation(NaiveNumber.class, 0) { + @Override + public NumberInterface instanceForString(String string) { + return new NaiveNumber(string); + } + + @Override + public NumberInterface instanceForPi() { + return new NaiveNumber(Math.PI); + } + }; + + /** + * The implementation for the infinite-precision BigDecimal. + */ + public static final NumberImplementation IMPLEMENTATION_PRECISE = new NumberImplementation(PreciseNumber.class, 0) { + @Override + public NumberInterface instanceForString(String string) { + return new PreciseNumber(string); + } + + @Override + public NumberInterface instanceForPi() { + NumberInterface C = FUNCTION_SQRT.apply(new PreciseNumber("10005")).multiply(new PreciseNumber("426880")); + NumberInterface M = PreciseNumber.ONE; + NumberInterface L = new PreciseNumber("13591409"); + NumberInterface X = M; + NumberInterface sum = L; + int termsNeeded = C.getMaxPrecision()/13 + 1; + + NumberInterface lSummand = new PreciseNumber("545140134"); + NumberInterface xMultiplier = new PreciseNumber("262537412") + .multiply(new PreciseNumber("1000000000")) + .add(new PreciseNumber("640768000")) + .negate(); + for(int i = 0; i < termsNeeded; i++){ + M = M + .multiply(new NaiveNumber(12*i+2).promoteTo(PreciseNumber.class)) + .multiply(new NaiveNumber(12*i+6).promoteTo(PreciseNumber.class)) + .multiply(new NaiveNumber(12*i+10).promoteTo(PreciseNumber.class)) + .divide(new NaiveNumber(Math.pow(i+1,3)).promoteTo(PreciseNumber.class)); + L = L.add(lSummand); + X = X.multiply(xMultiplier); + sum = sum.add(M.multiply(L).divide(X)); + } + return C.divide(sum); + } + }; + public StandardPlugin(PluginManager manager) { super(manager); } @@ -322,8 +463,8 @@ public class StandardPlugin extends Plugin { @Override public void onEnable() { - registerNumber("naive", NaiveNumber.class); - registerNumber("precise", PreciseNumber.class); + registerNumberImplementation("naive", IMPLEMENTATION_NAIVE); + registerNumberImplementation("precise", IMPLEMENTATION_PRECISE); registerOperator("+", OP_ADD); registerOperator("-", OP_SUBTRACT); @@ -337,6 +478,12 @@ public class StandardPlugin extends Plugin { registerFunction("exp", FUNCTION_EXP); registerFunction("ln", FUNCTION_LN); registerFunction("sqrt", FUNCTION_SQRT); + registerFunction("sin", functionSin); + registerFunction("cos", functionCos); + registerFunction("tan", functionTan); + registerFunction("sec", functionSec); + registerFunction("csc", functionCsc); + registerFunction("cot", functionCot); } @Override @@ -344,6 +491,13 @@ public class StandardPlugin extends Plugin { } + /** + * A factorial function that uses memoization for each number class; it efficiently + * computes factorials of non-negative integers. + * @param numberClass type of number to return. + * @param n non-negative integer. + * @return a number of numClass with value n factorial. + */ public static NumberInterface factorial(Class numberClass, int n){ if(!factorialLists.containsKey(numberClass)){ factorialLists.put(numberClass, new ArrayList<>()); @@ -359,4 +513,36 @@ public class StandardPlugin extends Plugin { return list.get(n); } + /** + * Returns the value of the Taylor series for sin (centered at 0) at x. + * @param x where the series is evaluated. + * @return the value of the series + */ + private static NumberInterface sinTaylor(NumberInterface x){ + NumberInterface power = x, multiplier = x.multiply(x).negate(), currentTerm = x, sum = x; + NumberInterface maxError = getMaxError(x); + int n = 1; + do{ + n += 2; + power = power.multiply(multiplier); + currentTerm = power.divide(factorial(x.getClass(), n)); + sum = sum.add(currentTerm); + } while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0); + return sum; + } + + /** + * Returns an equivalent angle in the interval [0, 2pi) + * @param phi an angle (in radians). + * @return theta in [0, 2pi) that differs from phi by a multiple of 2pi. + */ + private static NumberInterface getSmallAngle(NumberInterface phi, NumberInterface pi){ + NumberInterface twoPi = pi.multiply(new NaiveNumber("2").promoteTo(phi.getClass())); + NumberInterface theta = FUNCTION_ABS.apply(phi).subtract(twoPi + .multiply(FUNCTION_ABS.apply(phi).divide(twoPi).floor())); //Now theta is in [0, 2pi). + if(phi.signum() < 0){ + theta = twoPi.subtract(theta); + } + return theta; + } }