1
0
mirror of https://github.com/DanilaFe/abacus synced 2024-12-24 08:12:39 -08:00

Merge branch 'sin'

# Conflicts:
#	src/main/java/org/nwapw/abacus/Abacus.java
#	src/main/java/org/nwapw/abacus/plugin/PluginManager.java
This commit is contained in:
Danila Fedorin 2017-08-04 12:04:37 -07:00
commit 4c8dff6623
10 changed files with 461 additions and 84 deletions

View File

@ -2,12 +2,12 @@ package org.nwapw.abacus;
import org.nwapw.abacus.config.Configuration; import org.nwapw.abacus.config.Configuration;
import org.nwapw.abacus.fx.AbacusApplication; import org.nwapw.abacus.fx.AbacusApplication;
import org.nwapw.abacus.number.NaiveNumber;
import org.nwapw.abacus.number.NumberInterface; import org.nwapw.abacus.number.NumberInterface;
import org.nwapw.abacus.parsing.LexerTokenizer; import org.nwapw.abacus.parsing.LexerTokenizer;
import org.nwapw.abacus.parsing.ShuntingYardParser; import org.nwapw.abacus.parsing.ShuntingYardParser;
import org.nwapw.abacus.parsing.TreeBuilder; import org.nwapw.abacus.parsing.TreeBuilder;
import org.nwapw.abacus.plugin.ClassFinder; import org.nwapw.abacus.plugin.ClassFinder;
import org.nwapw.abacus.plugin.NumberImplementation;
import org.nwapw.abacus.plugin.PluginManager; import org.nwapw.abacus.plugin.PluginManager;
import org.nwapw.abacus.plugin.StandardPlugin; import org.nwapw.abacus.plugin.StandardPlugin;
import org.nwapw.abacus.tree.NumberReducer; import org.nwapw.abacus.tree.NumberReducer;
@ -15,7 +15,6 @@ import org.nwapw.abacus.tree.TreeNode;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
/** /**
* The main calculator class. This is responsible * The main calculator class. This is responsible
@ -24,10 +23,7 @@ import java.lang.reflect.InvocationTargetException;
*/ */
public class Abacus { public class Abacus {
/** public static final NumberImplementation DEFAULT_IMPLEMENTATION = StandardPlugin.IMPLEMENTATION_NAIVE;
* The default implementation to use for the number representation.
*/
public static final Class<? extends NumberInterface> DEFAULT_NUMBER = NaiveNumber.class;
/** /**
* The file used for saving and loading configuration. * The file used for saving and loading configuration.
*/ */
@ -147,15 +143,10 @@ public class Abacus {
* @return the resulting number. * @return the resulting number.
*/ */
public NumberInterface numberFromString(String numberString) { public NumberInterface numberFromString(String numberString) {
Class<? extends NumberInterface> toInstantiate = NumberImplementation toInstantiate =
pluginManager.numberFor(configuration.getNumberImplementation()); pluginManager.numberImplementationFor(configuration.getNumberImplementation());
if (toInstantiate == null) toInstantiate = DEFAULT_NUMBER; if (toInstantiate == null) toInstantiate = DEFAULT_IMPLEMENTATION;
try { return toInstantiate.instanceForString(numberString);
return toInstantiate.getConstructor(String.class).newInstance(numberString);
} catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
e.printStackTrace();
}
return null;
} }
} }

View File

@ -1,10 +1,6 @@
package org.nwapw.abacus.function; package org.nwapw.abacus.function;
import org.nwapw.abacus.number.NaiveNumber;
import org.nwapw.abacus.number.NumberInterface; import org.nwapw.abacus.number.NumberInterface;
import org.nwapw.abacus.number.PreciseNumber;
import java.util.HashMap;
/** /**
* A function that operates on one or more * A function that operates on one or more
@ -12,15 +8,6 @@ import java.util.HashMap;
*/ */
public abstract class Function { public abstract class Function {
/**
* A map to correctly promote different number implementations to each other.
*/
private static final HashMap<Class<? extends NumberInterface>, Integer> priorityMap =
new HashMap<Class<? extends NumberInterface>, Integer>() {{
put(NaiveNumber.class, 0);
put(PreciseNumber.class, 1);
}};
/** /**
* Checks whether the given params will work for the given function. * Checks whether the given params will work for the given function.
* *

View File

@ -220,7 +220,7 @@ public class AbacusController implements PluginListener {
public void onLoad(PluginManager manager) { public void onLoad(PluginManager manager) {
Configuration configuration = abacus.getConfiguration(); Configuration configuration = abacus.getConfiguration();
Set<String> disabledPlugins = configuration.getDisabledPlugins(); Set<String> disabledPlugins = configuration.getDisabledPlugins();
numberImplementationOptions.addAll(abacus.getPluginManager().getAllNumbers()); numberImplementationOptions.addAll(abacus.getPluginManager().getAllNumberImplementations());
String actualImplementation = configuration.getNumberImplementation(); String actualImplementation = configuration.getNumberImplementation();
String toSelect = (numberImplementationOptions.contains(actualImplementation)) ? actualImplementation : "<default>"; String toSelect = (numberImplementationOptions.contains(actualImplementation)) ? actualImplementation : "<default>";
numberImplementationBox.getSelectionModel().select(toSelect); numberImplementationBox.getSelectionModel().select(toSelect);

View File

@ -94,8 +94,23 @@ public class NaiveNumber implements NumberInterface {
} }
@Override @Override
public int ceiling() { public NumberInterface ceiling() {
return (int) Math.ceil(value); 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 @Override

View File

@ -83,7 +83,26 @@ public interface NumberInterface {
* Returns the least integer greater than or equal to the number. * Returns the least integer greater than or equal to the number.
* @return the least integer >= the number, if int can hold the value. * @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. * Promotes this class to another number class.

View File

@ -12,15 +12,15 @@ public class PreciseNumber implements NumberInterface {
/** /**
* The number one. * The number one.
*/ */
static final PreciseNumber ONE = new PreciseNumber(BigDecimal.ONE); public static final PreciseNumber ONE = new PreciseNumber(BigDecimal.ONE);
/** /**
* The number zero. * The number zero.
*/ */
static final PreciseNumber ZERO = new PreciseNumber(BigDecimal.ZERO); public static final PreciseNumber ZERO = new PreciseNumber(BigDecimal.ZERO);
/** /**
* The number ten. * 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. * The value of the PreciseNumber.
@ -99,8 +99,38 @@ public class PreciseNumber implements NumberInterface {
} }
@Override @Override
public int ceiling() { public NumberInterface ceiling() {
return (int) Math.ceil(value.doubleValue()); 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 @Override

View File

@ -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<Class<? extends NumberInterface>, Function<NumberInterface, NumberInterface>> promotionPaths;
/**
* The implementation class for this implementation.
*/
private Class<? extends NumberInterface> 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<? extends NumberInterface> 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<Class<? extends NumberInterface>, Function<NumberInterface, NumberInterface>> getPromotionPaths(){
return promotionPaths;
}
/**
* Gets the implementation class used by this implementation.
* @return the implementation class.
*/
public final Class<? extends NumberInterface> 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();
}

View File

@ -26,9 +26,9 @@ public abstract class Plugin {
*/ */
private Map<String, Operator> operators; private Map<String, Operator> operators;
/** /**
* A hash map of operators mapped to their string names. * The map of the number implementations this plugin provides.
*/ */
private Map<String, Class<? extends NumberInterface>> numbers; private Map<String, NumberImplementation> numberImplementations;
/** /**
* The plugin manager in which to search for functions * The plugin manager in which to search for functions
* not inside this package, * not inside this package,
@ -51,7 +51,7 @@ public abstract class Plugin {
this.manager = manager; this.manager = manager;
functions = new HashMap<>(); functions = new HashMap<>();
operators = new HashMap<>(); operators = new HashMap<>();
numbers = new HashMap<>(); numberImplementations = new HashMap<>();
enabled = false; 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<String> providedNumbers() { public final Set<String> providedNumberImplementations(){
return numbers.keySet(); 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. * @param name the name of the number implementation to look up.
* @return the class, or null if the plugin doesn't provide it. * @return the number implementation associated with that name, or null if the plugin doesn't provide it.
*/ */
public final Class<? extends NumberInterface> getNumber(String numberName) { public final NumberImplementation getNumberImplementation(String name){
return numbers.get(numberName); return numberImplementations.get(name);
} }
/** /**
@ -158,16 +158,13 @@ public abstract class Plugin {
} }
/** /**
* To be used in load(). Registers a number class * To be used in load(). Registers a new number implementation with the plugin.
* with the plugin internally, which makes it possible * This makes it accessible to the plugin manager.
* for the user to select it as an "implementation" for the * @param name the name of the implementation.
* number that they would like to use. * @param implementation the actual implementation class to register.
*
* @param name the name to register it under.
* @param toRegister the class to register.
*/ */
protected final void registerNumber(String name, Class<? extends NumberInterface> toRegister) { protected final void registerNumberImplementation(String name, NumberImplementation implementation){
numbers.put(name, toRegister); numberImplementations.put(name, implementation);
} }
/** /**
@ -194,6 +191,30 @@ public abstract class Plugin {
return manager.operatorFor(name); 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<? extends NumberInterface> forClass){
return manager.piFor(forClass);
}
/** /**
* Abstract method to be overridden by plugin implementation, in which the plugins * Abstract method to be overridden by plugin implementation, in which the plugins
* are supposed to register the functions they provide and do any other * are supposed to register the functions they provide and do any other

View File

@ -33,10 +33,19 @@ public class PluginManager {
*/ */
private Map<String, Operator> cachedOperators; private Map<String, Operator> 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. * been cached, that is, found in a plugin and returned.
*/ */
private Map<String, Class<? extends NumberInterface>> cachedNumbers; private Map<String, NumberImplementation> cachedNumberImplementations;
/**
* The list of number implementations that have been
* found by their implementation class.
*/
private Map<Class<? extends NumberInterface>, NumberImplementation> cachedInterfaceImplementations;
/**
* The pi values for each implementation class that have already been computer.
*/
private Map<Class<? extends NumberInterface>, NumberInterface> cachedPi;
/** /**
* List of all functions loaded by the plugins. * List of all functions loaded by the plugins.
*/ */
@ -46,9 +55,9 @@ public class PluginManager {
*/ */
private Set<String> allOperators; private Set<String> allOperators;
/** /**
* List of all numbers loaded by the plugins. * List of all the number implementations loaded by the plugins.
*/ */
private Set<String> allNumbers; private Set<String> allNumberImplementations;
/** /**
* The list of plugin listeners attached to this instance. * The list of plugin listeners attached to this instance.
*/ */
@ -68,10 +77,12 @@ public class PluginManager {
plugins = new HashSet<>(); plugins = new HashSet<>();
cachedFunctions = new HashMap<>(); cachedFunctions = new HashMap<>();
cachedOperators = new HashMap<>(); cachedOperators = new HashMap<>();
cachedNumbers = new HashMap<>(); cachedNumberImplementations = new HashMap<>();
cachedInterfaceImplementations = new HashMap<>();
cachedPi = new HashMap<>();
allFunctions = new HashSet<>(); allFunctions = new HashSet<>();
allOperators = new HashSet<>(); allOperators = new HashSet<>();
allNumbers = new HashSet<>(); allNumberImplementations = new HashSet<>();
listeners = 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 getFunction the function to get the T value under the given name
* @param name the name to search for * @param name the name to search for
* @param <T> the type of element being search * @param <T> the type of element being search
* @param <K> the type of key that the cache is indexed by.
* @return the retrieved element, or null if it was not found. * @return the retrieved element, or null if it was not found.
*/ */
private static <T> T searchCached(Collection<Plugin> plugins, Map<String, T> cache, private static <T, K> T searchCached(Collection<Plugin> plugins, Map<K, T> cache,
java.util.function.Function<Plugin, Set<String>> setFunction, java.util.function.Function<Plugin, Set<K>> setFunction,
java.util.function.BiFunction<Plugin, String, T> getFunction, java.util.function.BiFunction<Plugin, K, T> getFunction,
String name) { K name) {
if (cache.containsKey(name)) return cache.get(name); if (cache.containsKey(name)) return cache.get(name);
T loadedValue = null; 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. * @param name the name of the implementation.
* @return the implementation class * @return the implementation.
*/ */
public Class<? extends NumberInterface> numberFor(String name) { public NumberImplementation numberImplementationFor(String name){
return searchCached(plugins, cachedNumbers, Plugin::providedNumbers, Plugin::getNumber, 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<? extends NumberInterface> 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<? extends NumberInterface> 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; if(disabledPlugins.contains(plugin.getClass().getName())) continue;
allFunctions.addAll(plugin.providedFunctions()); allFunctions.addAll(plugin.providedFunctions());
allOperators.addAll(plugin.providedOperators()); allOperators.addAll(plugin.providedOperators());
allNumbers.addAll(plugin.providedNumbers()); allNumberImplementations.addAll(plugin.providedNumberImplementations());
} }
listeners.forEach(e -> e.onLoad(this)); listeners.forEach(e -> e.onLoad(this));
} }
@ -193,10 +243,13 @@ public class PluginManager {
} }
cachedFunctions.clear(); cachedFunctions.clear();
cachedOperators.clear(); cachedOperators.clear();
cachedNumbers.clear(); cachedNumberImplementations.clear();
cachedInterfaceImplementations.clear();
cachedPi.clear();
allFunctions.clear(); allFunctions.clear();
allOperators.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<String> getAllNumbers() { public Set<String> getAllNumberImplementations(){
return allNumbers; return allNumberImplementations;
} }
/** /**

View File

@ -105,7 +105,9 @@ public class StandardPlugin extends Plugin {
//private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>(); //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
@Override @Override
protected boolean matchesParams(NumberInterface[] params) { 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 @Override
@ -182,7 +184,7 @@ public class StandardPlugin extends Plugin {
//right and left refer to lhs and rhs in the above inequality. //right and left refer to lhs and rhs in the above inequality.
NumberInterface sum = NaiveNumber.ONE.promoteTo(params[0].getClass()); NumberInterface sum = NaiveNumber.ONE.promoteTo(params[0].getClass());
NumberInterface nextNumerator = params[0]; 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{ do{
sum = sum.add(nextNumerator.divide(factorial(params[0].getClass(), n+1))); sum = sum.add(nextNumerator.divide(factorial(params[0].getClass(), n+1)));
n++; 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) { public StandardPlugin(PluginManager manager) {
super(manager); super(manager);
} }
@ -322,8 +463,8 @@ public class StandardPlugin extends Plugin {
@Override @Override
public void onEnable() { public void onEnable() {
registerNumber("naive", NaiveNumber.class); registerNumberImplementation("naive", IMPLEMENTATION_NAIVE);
registerNumber("precise", PreciseNumber.class); registerNumberImplementation("precise", IMPLEMENTATION_PRECISE);
registerOperator("+", OP_ADD); registerOperator("+", OP_ADD);
registerOperator("-", OP_SUBTRACT); registerOperator("-", OP_SUBTRACT);
@ -337,6 +478,12 @@ public class StandardPlugin extends Plugin {
registerFunction("exp", FUNCTION_EXP); registerFunction("exp", FUNCTION_EXP);
registerFunction("ln", FUNCTION_LN); registerFunction("ln", FUNCTION_LN);
registerFunction("sqrt", FUNCTION_SQRT); registerFunction("sqrt", FUNCTION_SQRT);
registerFunction("sin", functionSin);
registerFunction("cos", functionCos);
registerFunction("tan", functionTan);
registerFunction("sec", functionSec);
registerFunction("csc", functionCsc);
registerFunction("cot", functionCot);
} }
@Override @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<? extends NumberInterface> numberClass, int n){ public static NumberInterface factorial(Class<? extends NumberInterface> numberClass, int n){
if(!factorialLists.containsKey(numberClass)){ if(!factorialLists.containsKey(numberClass)){
factorialLists.put(numberClass, new ArrayList<>()); factorialLists.put(numberClass, new ArrayList<>());
@ -359,4 +513,36 @@ public class StandardPlugin extends Plugin {
return list.get(n); 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;
}
} }