mirror of https://github.com/DanilaFe/abacus
Compare commits
176 Commits
v0.1.2-ALP
...
master
Author | SHA1 | Date |
---|---|---|
Danila Fedorin | 15394b7ea0 | |
Danila Fedorin | cc2da711e7 | |
Danila Fedorin | ef39bcbaa2 | |
Danila Fedorin | ac17246317 | |
Danila Fedorin | 18e0bdebc5 | |
Danila Fedorin | 251d0fc2c5 | |
Danila Fedorin | 93c1c53612 | |
Danila Fedorin | 0b6798e28d | |
Danila Fedorin | 4188c83a66 | |
Danila Fedorin | af988a34d1 | |
Danila Fedorin | 751fd97fcb | |
Danila Fedorin | 899e0e65a5 | |
Danila Fedorin | b4b64ac963 | |
Danila Fedorin | 50cc51d089 | |
Danila Fedorin | 8f682e96af | |
Danila Fedorin | 9bdf188ca7 | |
Danila Fedorin | 9fdb3fc0d9 | |
Danila Fedorin | 095d374949 | |
Danila Fedorin | 981211ccfa | |
Danila Fedorin | d91536e746 | |
Danila Fedorin | 7c252fddf1 | |
Danila Fedorin | 0d26167f31 | |
Danila Fedorin | 07abe4d17a | |
Danila Fedorin | 8ef0904d26 | |
Danila Fedorin | 92489551ca | |
Danila Fedorin | 2a9026f748 | |
Danila Fedorin | 08e5b69c04 | |
Danila Fedorin | 6a0b667c32 | |
Danila Fedorin | 5a1fdfe4bc | |
Danila Fedorin | 378ff946d9 | |
Danila Fedorin | 0511c58b13 | |
Danila Fedorin | e82a13cde5 | |
Danila Fedorin | 40362a7afe | |
Danila Fedorin | c990d4c50a | |
Danila Fedorin | d7bb838866 | |
Danila Fedorin | e05b2ac8d5 | |
Danila Fedorin | b4214f5714 | |
Danila Fedorin | bd02749706 | |
Danila Fedorin | f809183126 | |
Danila Fedorin | 579ff78a99 | |
Danila Fedorin | 81d0999c11 | |
Danila Fedorin | 4fd8f7badf | |
Danila Fedorin | bc475a22f9 | |
Danila Fedorin | e0ccb67ad3 | |
Danila Fedorin | ea4588be44 | |
Danila Fedorin | 31996219ad | |
Danila Fedorin | a3bfc34c1c | |
Danila Fedorin | 8dc7acd4b3 | |
Danila Fedorin | 76fcd8ec1c | |
Danila Fedorin | fbdf2c7e52 | |
Danila Fedorin | 3057f66e66 | |
Danila Fedorin | f385a48aa2 | |
Danila Fedorin | fd3f56aa8f | |
Danila Fedorin | e364f4e94b | |
Danila Fedorin | 4c94abb18b | |
Danila Fedorin | ba63dd7874 | |
Danila Fedorin | 566598b702 | |
Danila Fedorin | eb91a5b875 | |
Danila Fedorin | fcd4694203 | |
Danila Fedorin | 566831246c | |
Danila Fedorin | ad8a0a9b2a | |
Danila Fedorin | e430e738cf | |
Danila Fedorin | f6e326e0f1 | |
Danila Fedorin | 07581557c7 | |
Danila Fedorin | 14ac9c67f4 | |
Danila Fedorin | 0ff071e212 | |
Danila Fedorin | 88e3bb7109 | |
Danila Fedorin | 540e5d6099 | |
Danila Fedorin | c9e93d87a2 | |
Danila Fedorin | 337edd68fa | |
Danila Fedorin | 08967fbb8f | |
Danila Fedorin | 46f78bb2ed | |
Danila Fedorin | 5b4773dee1 | |
Danila Fedorin | be94394a5c | |
Danila Fedorin | 45de25cd50 | |
Danila Fedorin | 52ab357fe1 | |
Danila Fedorin | 1575d3e574 | |
Danila Fedorin | 87529da15f | |
Danila Fedorin | 7cd117dac1 | |
Danila Fedorin | 8975bfdb99 | |
Danila Fedorin | 00f8475044 | |
Danila Fedorin | f0efae21be | |
Danila Fedorin | 9f11fd20a2 | |
Danila Fedorin | 1667edc72b | |
Danila Fedorin | 5d2a988f75 | |
Danila Fedorin | 91978686e6 | |
Danila Fedorin | 9a8d0afc19 | |
Danila Fedorin | 5aba5c350b | |
Danila Fedorin | 21b7bd5e2b | |
Danila Fedorin | f2ac7b109a | |
Danila Fedorin | 67d240b8f6 | |
Danila Fedorin | dc4eee6342 | |
Danila Fedorin | 6909f210d6 | |
Danila Fedorin | 059226a4d4 | |
Danila Fedorin | ef1890f24d | |
Danila Fedorin | 782669a32b | |
Danila Fedorin | 924849bd8b | |
Danila Fedorin | 91986112a1 | |
Danila Fedorin | 58fea9c52b | |
Danila Fedorin | 863be5bcfc | |
Danila Fedorin | f0e38fed87 | |
Danila Fedorin | fd246f935c | |
Danila Fedorin | 6604af5b0f | |
Danila Fedorin | d49a763e8f | |
Danila Fedorin | 48a4d8adc2 | |
Danila Fedorin | 5417b45106 | |
Danila Fedorin | 585cabc478 | |
Danila Fedorin | 28802cfed3 | |
Danila Fedorin | 428df8bfd3 | |
Danila Fedorin | 146f3994ef | |
Danila Fedorin | daffdb6b42 | |
Danila Fedorin | 178f59ef7b | |
Danila Fedorin | 61616a428a | |
Danila Fedorin | 9c77fa8aeb | |
Danila Fedorin | 9ddfeb02cf | |
Danila Fedorin | bc4a26aafb | |
Danila Fedorin | 1f6aa70230 | |
Danila Fedorin | e62722ce2f | |
Danila Fedorin | ce82fd56dd | |
Danila Fedorin | 6a65e66935 | |
Danila Fedorin | e172108476 | |
Danila Fedorin | 2b700d3911 | |
Danila Fedorin | f7c07ca04d | |
Danila Fedorin | ecb5139e70 | |
Danila Fedorin | 453cd0ea77 | |
Danila Fedorin | 7a296e4e8b | |
Danila Fedorin | cbceee4abc | |
Danila Fedorin | 8ea34b8f6e | |
Danila Fedorin | 672252ef41 | |
Danila Fedorin | 824f391fc7 | |
Danila Fedorin | 63a160659a | |
Danila Fedorin | 879d09e5b8 | |
Danila Fedorin | ae0ec0c375 | |
Danila Fedorin | 337a38a07d | |
Danila Fedorin | fbfc68ebfe | |
Danila Fedorin | 01e7a03444 | |
Danila Fedorin | 0cb180284a | |
Danila Fedorin | 192269ea9a | |
Danila Fedorin | f134e5aa04 | |
Danila Fedorin | e3c37cf10a | |
Danila Fedorin | 823c788148 | |
Danila Fedorin | ece9f1ae04 | |
Danila Fedorin | fbc12ec41c | |
Danila Fedorin | 385a64eace | |
Danila Fedorin | c2feedee32 | |
Danila Fedorin | b98b08b872 | |
Danila Fedorin | f8eb051583 | |
Danila Fedorin | 20b2e77ee1 | |
Danila Fedorin | bfc1ed5819 | |
Danila Fedorin | 9d52d55e68 | |
Danila Fedorin | 07d7343339 | |
Danila Fedorin | 73075c57b9 | |
Danila Fedorin | 5b1a48c02e | |
Danila Fedorin | ca2681cc21 | |
Danila Fedorin | 8a3c614602 | |
Danila Fedorin | da1c78945e | |
Danila Fedorin | 225a926f86 | |
Danila Fedorin | f83f2a7aaa | |
Danila Fedorin | d04adf4da5 | |
Danila Fedorin | 1f0addccea | |
Danila Fedorin | 1a47e07e97 | |
Danila Fedorin | 26305c3bae | |
Danila Fedorin | 6b9252f902 | |
Danila Fedorin | bc26ad0b88 | |
Danila Fedorin | c5cd0f81ad | |
Danila Fedorin | ac19c7b230 | |
Danila Fedorin | 40c80db914 | |
Danila Fedorin | 00462281fe | |
Danila Fedorin | 01f80bbb53 | |
Danila Fedorin | 553c7354c1 | |
Danila Fedorin | 50ede6460c | |
Danila Fedorin | beb583a231 | |
Danila Fedorin | e0ff229df4 | |
Danila Fedorin | 1c751353f1 | |
Danila Fedorin | 0a15043b63 | |
Danila Fedorin | 21e059c1ca |
|
@ -24,7 +24,9 @@ hs_err_pid*
|
|||
# Custom Stuff
|
||||
# Gradle
|
||||
.gradle/*
|
||||
build/*
|
||||
**/build/*
|
||||
**/out/**
|
||||
**/.DS_Store
|
||||
|
||||
# IntelliJ
|
||||
.idea/*
|
||||
|
|
18
build.gradle
18
build.gradle
|
@ -1,13 +1,29 @@
|
|||
buildscript {
|
||||
ext.kotlin_version = '1.2.40'
|
||||
ext.dokka_version = '0.9.16'
|
||||
|
||||
repositories {
|
||||
jcenter()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
|
||||
classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
|
||||
}
|
||||
}
|
||||
|
||||
subprojects {
|
||||
|
||||
apply plugin: 'java'
|
||||
apply plugin: 'kotlin'
|
||||
apply plugin: 'org.jetbrains.dokka'
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:1.1.3"
|
||||
compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:1.2.40"
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -1,8 +1,3 @@
|
|||
plugins {
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.1.3'
|
||||
}
|
||||
|
||||
dependencies {
|
||||
compile 'com.moandjiezana.toml:toml4j:0.7.1'
|
||||
testCompile 'junit:junit:4.12'
|
||||
}
|
||||
|
|
|
@ -1,135 +0,0 @@
|
|||
package org.nwapw.abacus;
|
||||
|
||||
import org.nwapw.abacus.config.Configuration;
|
||||
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.NumberImplementation;
|
||||
import org.nwapw.abacus.plugin.PluginManager;
|
||||
import org.nwapw.abacus.plugin.StandardPlugin;
|
||||
import org.nwapw.abacus.tree.NumberReducer;
|
||||
import org.nwapw.abacus.tree.TreeNode;
|
||||
|
||||
/**
|
||||
* The main calculator class. This is responsible
|
||||
* for piecing together all of the components, allowing
|
||||
* their interaction with each other.
|
||||
*/
|
||||
public class Abacus {
|
||||
|
||||
/**
|
||||
* The default number implementation to be used if no other one is available / selected.
|
||||
*/
|
||||
public static final NumberImplementation DEFAULT_IMPLEMENTATION = StandardPlugin.IMPLEMENTATION_NAIVE;
|
||||
|
||||
/**
|
||||
* The plugin manager responsible for
|
||||
* loading and unloading plugins,
|
||||
* and getting functions from them.
|
||||
*/
|
||||
private PluginManager pluginManager;
|
||||
/**
|
||||
* The reducer used to evaluate the tree.
|
||||
*/
|
||||
private NumberReducer numberReducer;
|
||||
/**
|
||||
* The configuration loaded from a file.
|
||||
*/
|
||||
private Configuration configuration;
|
||||
/**
|
||||
* The tree builder used to construct a tree
|
||||
* from a string.
|
||||
*/
|
||||
private TreeBuilder treeBuilder;
|
||||
|
||||
/**
|
||||
* Creates a new instance of the Abacus calculator.
|
||||
*
|
||||
* @param configuration the configuration object for this Abacus instance.
|
||||
*/
|
||||
public Abacus(Configuration configuration) {
|
||||
pluginManager = new PluginManager(this);
|
||||
numberReducer = new NumberReducer(this);
|
||||
this.configuration = new Configuration(configuration);
|
||||
LexerTokenizer lexerTokenizer = new LexerTokenizer();
|
||||
ShuntingYardParser shuntingYardParser = new ShuntingYardParser(this);
|
||||
treeBuilder = new TreeBuilder<>(lexerTokenizer, shuntingYardParser);
|
||||
|
||||
pluginManager.addListener(shuntingYardParser);
|
||||
pluginManager.addListener(lexerTokenizer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the current tree builder.
|
||||
*
|
||||
* @return the main tree builder in this abacus instance.
|
||||
*/
|
||||
public TreeBuilder getTreeBuilder() {
|
||||
return treeBuilder;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the current plugin manager,
|
||||
*
|
||||
* @return the plugin manager in this abacus instance.
|
||||
*/
|
||||
public PluginManager getPluginManager() {
|
||||
return pluginManager;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the reducer that is responsible for transforming
|
||||
* an expression into a number.
|
||||
*
|
||||
* @return the number reducer in this abacus instance.
|
||||
*/
|
||||
public NumberReducer getNumberReducer() {
|
||||
return numberReducer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the configuration object associated with this instance.
|
||||
*
|
||||
* @return the configuration object.
|
||||
*/
|
||||
public Configuration getConfiguration() {
|
||||
return configuration;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a string into a tree structure using the main
|
||||
* tree builder.
|
||||
*
|
||||
* @param input the input string to parse
|
||||
* @return the resulting tree, null if the tree builder or the produced tree are null.
|
||||
*/
|
||||
public TreeNode parseString(String input) {
|
||||
return treeBuilder.fromString(input);
|
||||
}
|
||||
|
||||
/**
|
||||
* Evaluates the given tree using the main
|
||||
* number reducer.
|
||||
*
|
||||
* @param tree the tree to reduce, must not be null.
|
||||
* @return the resulting number, or null of the reduction failed.
|
||||
*/
|
||||
public NumberInterface evaluateTree(TreeNode tree) {
|
||||
return tree.reduce(numberReducer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a number from a string.
|
||||
*
|
||||
* @param numberString the string to create the number from.
|
||||
* @return the resulting number.
|
||||
*/
|
||||
public NumberInterface numberFromString(String numberString) {
|
||||
NumberImplementation toInstantiate =
|
||||
pluginManager.numberImplementationFor(configuration.getNumberImplementation());
|
||||
if (toInstantiate == null) toInstantiate = DEFAULT_IMPLEMENTATION;
|
||||
|
||||
return toInstantiate.instanceForString(numberString);
|
||||
}
|
||||
}
|
|
@ -1,159 +0,0 @@
|
|||
package org.nwapw.abacus.config;
|
||||
|
||||
import com.moandjiezana.toml.Toml;
|
||||
import com.moandjiezana.toml.TomlWriter;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* The configuration object that stores
|
||||
* options that the user can change.
|
||||
*/
|
||||
public class Configuration {
|
||||
|
||||
/**
|
||||
* The defaults TOML string.
|
||||
*/
|
||||
private static final String DEFAULT_CONFIG =
|
||||
"numberImplementation = \"naive\"\n" +
|
||||
"disabledPlugins = []";
|
||||
/**
|
||||
* The defaults TOML object, parsed from the string.
|
||||
*/
|
||||
private static final Toml DEFAULT_TOML = new Toml().read(DEFAULT_CONFIG);
|
||||
/**
|
||||
* The TOML writer used to write this configuration to a file.
|
||||
*/
|
||||
private static final TomlWriter TOML_WRITER = new TomlWriter();
|
||||
|
||||
/**
|
||||
* The computation delay for which the thread can run without interruption.
|
||||
*/
|
||||
private double computationDelay = 0;
|
||||
/**
|
||||
* The implementation of the number that should be used.
|
||||
*/
|
||||
private String numberImplementation = "<default>";
|
||||
/**
|
||||
* The list of disabled plugins in this Configuration.
|
||||
*/
|
||||
private Set<String> disabledPlugins = new HashSet<>();
|
||||
|
||||
/**
|
||||
* Creates a new configuration form the given configuration.
|
||||
*
|
||||
* @param copyFrom the configuration to copy.
|
||||
*/
|
||||
public Configuration(Configuration copyFrom) {
|
||||
copyFrom(copyFrom);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new configuration with the given values.
|
||||
*
|
||||
* @param computationDelay the delay before the computation gets killed.
|
||||
* @param numberImplementation the number implementation, like "naive" or "precise"
|
||||
* @param disabledPlugins the list of disabled plugins.
|
||||
*/
|
||||
public Configuration(double computationDelay, String numberImplementation, String[] disabledPlugins) {
|
||||
this.computationDelay = computationDelay;
|
||||
this.numberImplementation = numberImplementation;
|
||||
this.disabledPlugins.addAll(Arrays.asList(disabledPlugins));
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads a configuration from a given file, keeping non-specified fields default.
|
||||
*
|
||||
* @param fromFile the file to load from.
|
||||
*/
|
||||
public Configuration(File fromFile) {
|
||||
if (!fromFile.exists()) return;
|
||||
copyFrom(new Toml(DEFAULT_TOML).read(fromFile).to(Configuration.class));
|
||||
}
|
||||
|
||||
/**
|
||||
* Copies the values from the given configuration into this one.
|
||||
*
|
||||
* @param otherConfiguration the configuration to copy from.
|
||||
*/
|
||||
public void copyFrom(Configuration otherConfiguration) {
|
||||
this.computationDelay = otherConfiguration.computationDelay;
|
||||
this.numberImplementation = otherConfiguration.numberImplementation;
|
||||
this.disabledPlugins.addAll(otherConfiguration.disabledPlugins);
|
||||
}
|
||||
|
||||
/**
|
||||
* Saves this configuration to the given file, creating
|
||||
* any directories that do not exist.
|
||||
*
|
||||
* @param file the file to save to.
|
||||
*/
|
||||
public void saveTo(File file) {
|
||||
if (file.getParentFile() != null) file.getParentFile().mkdirs();
|
||||
try {
|
||||
TOML_WRITER.write(this, file);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value of this configuration as a string.
|
||||
*
|
||||
* @return the string that represents this configuration.
|
||||
*/
|
||||
public String asTomlString() {
|
||||
return TOML_WRITER.write(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the number implementation from this configuration.
|
||||
*
|
||||
* @return the number implementation.
|
||||
*/
|
||||
public String getNumberImplementation() {
|
||||
return numberImplementation;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the number implementation for the configuration
|
||||
*
|
||||
* @param numberImplementation the number implementation.
|
||||
*/
|
||||
public void setNumberImplementation(String numberImplementation) {
|
||||
this.numberImplementation = numberImplementation;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the list of disabled plugins.
|
||||
*
|
||||
* @return the list of disabled plugins.
|
||||
*/
|
||||
public Set<String> getDisabledPlugins() {
|
||||
return disabledPlugins;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Gets the computation delay specified in the configuration.
|
||||
*
|
||||
* @return the computaton delay.
|
||||
*/
|
||||
public double getComputationDelay() {
|
||||
return computationDelay;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the computation delay.
|
||||
*
|
||||
* @param computationDelay the new computation delay.
|
||||
*/
|
||||
public void setComputationDelay(double computationDelay) {
|
||||
this.computationDelay = computationDelay;
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,9 @@
|
|||
package org.nwapw.abacus.exception;
|
||||
|
||||
public class AbacusException extends RuntimeException {
|
||||
|
||||
public AbacusException(String baseMessage, String description){
|
||||
super(baseMessage + ((description.equals("")) ? "." : (": " + description)));
|
||||
}
|
||||
|
||||
}
|
|
@ -1,16 +1,16 @@
|
|||
package org.nwapw.abacus.number;
|
||||
package org.nwapw.abacus.exception;
|
||||
|
||||
/**
|
||||
* Exception thrown when the computation is interrupted by
|
||||
* the user.
|
||||
*/
|
||||
public class ComputationInterruptedException extends RuntimeException {
|
||||
public class ComputationInterruptedException extends AbacusException {
|
||||
|
||||
/**
|
||||
* Creates a new exception of this type.
|
||||
*/
|
||||
public ComputationInterruptedException() {
|
||||
super("Computation interrupted by user.");
|
||||
super("Computation interrupted", "");
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,24 @@
|
|||
package org.nwapw.abacus.exception;
|
||||
|
||||
/**
|
||||
* Exception thrown by the Context in cases where lookup fails
|
||||
* where it should not.
|
||||
*/
|
||||
public class ContextException extends AbacusException {
|
||||
|
||||
/**
|
||||
* Creates a new ContextException without an extra message.
|
||||
*/
|
||||
public ContextException() {
|
||||
this("");
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a ContextException with the given message.
|
||||
* @param message the message to use.
|
||||
*/
|
||||
public ContextException(String message){
|
||||
super("Context exception", message);
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,24 @@
|
|||
package org.nwapw.abacus.exception;
|
||||
|
||||
/**
|
||||
* Exception thrown if the function parameters do not match
|
||||
* requirements.
|
||||
*/
|
||||
public class DomainException extends AbacusException {
|
||||
|
||||
/**
|
||||
* Creates a new DomainException.
|
||||
* @param reason the reason for which the exception is thrown.
|
||||
*/
|
||||
public DomainException(String reason) {
|
||||
super("Domain error", reason);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new DomainException with a default message.
|
||||
*/
|
||||
public DomainException(){
|
||||
this("");
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,25 @@
|
|||
package org.nwapw.abacus.exception;
|
||||
|
||||
/**
|
||||
* Exception thrown by the NumberReducer if something goes wrong when
|
||||
* transforming a parse tree into a single value.
|
||||
*/
|
||||
public class NumberReducerException extends AbacusException {
|
||||
|
||||
/**
|
||||
* Creates a new NumberReducerException with
|
||||
* no additional message.
|
||||
*/
|
||||
public NumberReducerException() {
|
||||
this("");
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new NumberReducerException with the given message.
|
||||
* @param message the message.
|
||||
*/
|
||||
public NumberReducerException(String message) {
|
||||
super("Error evaluating expression", message);
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,23 @@
|
|||
package org.nwapw.abacus.exception;
|
||||
|
||||
/**
|
||||
* Exception thrown by parsers.
|
||||
*/
|
||||
public class ParseException extends AbacusException {
|
||||
|
||||
/**
|
||||
* Creates a new ParseException with no additional message.
|
||||
*/
|
||||
public ParseException(){
|
||||
this("");
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new ParseException with the given additional message.
|
||||
* @param message the message.
|
||||
*/
|
||||
public ParseException(String message){
|
||||
super("Failed to parse string", message);
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,24 @@
|
|||
package org.nwapw.abacus.exception;
|
||||
|
||||
/**
|
||||
* Exception thrown when a promotion fails.
|
||||
*/
|
||||
public class PromotionException extends AbacusException {
|
||||
|
||||
/**
|
||||
* Creates a new PromotionException with the default message
|
||||
* and no additional information.
|
||||
*/
|
||||
public PromotionException() {
|
||||
this("");
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new PromotionException with the given additional message.
|
||||
* @param message the additional message to include with the error.
|
||||
*/
|
||||
public PromotionException(String message) {
|
||||
super("Failed to promote number instances", message);
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,23 @@
|
|||
package org.nwapw.abacus.exception;
|
||||
|
||||
/**
|
||||
* An exception thrown from TreeReducers.
|
||||
*/
|
||||
public class ReductionException extends AbacusException {
|
||||
|
||||
/**
|
||||
* Creates a new EvaluationException with the default string.
|
||||
*/
|
||||
public ReductionException() {
|
||||
this("");
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new EvaluationError with the given message string.
|
||||
* @param message the message string.
|
||||
*/
|
||||
public ReductionException(String message) {
|
||||
super("Evaluation error", message);
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,23 @@
|
|||
package org.nwapw.abacus.exception;
|
||||
|
||||
/**
|
||||
* Exception thrown by Lexers when they are unable to tokenize the input string.
|
||||
*/
|
||||
public class TokenizeException extends AbacusException {
|
||||
|
||||
/**
|
||||
* Create a new tokenize exception with no additional data.
|
||||
*/
|
||||
public TokenizeException() {
|
||||
this("");
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new tokenize exception with the given message.
|
||||
* @param message the message to use.
|
||||
*/
|
||||
public TokenizeException(String message){
|
||||
super("Failed to tokenize string", message);
|
||||
}
|
||||
|
||||
}
|
|
@ -6,6 +6,6 @@ package org.nwapw.abacus.function;
|
|||
*/
|
||||
public enum DocumentationType {
|
||||
|
||||
FUNCTION
|
||||
FUNCTION, TREE_VALUE_FUNCTION
|
||||
|
||||
}
|
||||
|
|
|
@ -1,39 +0,0 @@
|
|||
package org.nwapw.abacus.function;
|
||||
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
|
||||
/**
|
||||
* A function that operates on one or more
|
||||
* inputs and returns a single number.
|
||||
*/
|
||||
public abstract class Function {
|
||||
|
||||
/**
|
||||
* Checks whether the given params will work for the given function.
|
||||
*
|
||||
* @param params the given params
|
||||
* @return true if the params can be used with this function.
|
||||
*/
|
||||
protected abstract boolean matchesParams(NumberInterface[] params);
|
||||
|
||||
/**
|
||||
* Internal apply implementation, which already receives appropriately promoted
|
||||
* parameters that have bee run through matchesParams
|
||||
*
|
||||
* @param params the promoted parameters.
|
||||
* @return the return value of the function.
|
||||
*/
|
||||
protected abstract NumberInterface applyInternal(NumberInterface[] params);
|
||||
|
||||
/**
|
||||
* Function to check, promote arguments and run the function.
|
||||
*
|
||||
* @param params the raw input parameters.
|
||||
* @return the return value of the function, or null if an error occurred.
|
||||
*/
|
||||
public NumberInterface apply(NumberInterface... params) {
|
||||
if (!matchesParams(params)) return null;
|
||||
return applyInternal(params);
|
||||
}
|
||||
|
||||
}
|
|
@ -1,9 +1,8 @@
|
|||
package org.nwapw.abacus.lexing;
|
||||
|
||||
import org.nwapw.abacus.lexing.pattern.EndNode;
|
||||
import org.nwapw.abacus.lexing.pattern.Match;
|
||||
import org.nwapw.abacus.lexing.pattern.Pattern;
|
||||
import org.nwapw.abacus.lexing.pattern.PatternNode;
|
||||
import org.nwapw.abacus.lexing.pattern.nodes.EndNode;
|
||||
import org.nwapw.abacus.lexing.pattern.nodes.PatternNode;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
|
@ -80,10 +79,10 @@ public class Lexer<T> {
|
|||
|
||||
index++;
|
||||
}
|
||||
matches.sort((a, b) -> compare.compare(a.getType(), b.getType()));
|
||||
if (compare != null) {
|
||||
matches.sort(Comparator.comparingInt(a -> a.getContent().length()));
|
||||
Collections.sort(matches, (a, b) -> compare.compare(a.getType(), b.getType()));
|
||||
}
|
||||
Collections.sort(matches, (o1, o2) -> o1.getContent().length() - o2.getContent().length());
|
||||
return matches.isEmpty() ? null : matches.get(matches.size() - 1);
|
||||
}
|
||||
|
||||
|
@ -137,7 +136,10 @@ public class Lexer<T> {
|
|||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return Objects.hash(name, id);
|
||||
return Arrays.hashCode(new Object[] {
|
||||
this.name,
|
||||
this.id
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
package org.nwapw.abacus.lexing;
|
||||
|
||||
/**
|
||||
* A match that has been generated by the lexer.
|
|
@ -1,10 +1,11 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
|
||||
import org.nwapw.abacus.lexing.pattern.nodes.*;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Stack;
|
||||
import java.util.function.Function;
|
||||
|
||||
/**
|
||||
* A pattern that can be compiled from a string and used in lexing.
|
||||
|
@ -34,8 +35,8 @@ public class Pattern<T> {
|
|||
* A map of regex operator to functions that modify a PatternChain
|
||||
* with the appropriate operation.
|
||||
*/
|
||||
private Map<Character, Function<PatternChain<T>, PatternChain<T>>> operations =
|
||||
new HashMap<Character, Function<PatternChain<T>, PatternChain<T>>>() {{
|
||||
private Map<Character, Transformation<T>> operations =
|
||||
new HashMap<Character, Transformation<T>>() {{
|
||||
put('+', Pattern.this::transformPlus);
|
||||
put('*', Pattern.this::transformStar);
|
||||
put('?', Pattern.this::transformQuestion);
|
||||
|
@ -88,7 +89,7 @@ public class Pattern<T> {
|
|||
* @return the modified chain.
|
||||
*/
|
||||
private PatternChain<T> transformPlus(PatternChain<T> chain) {
|
||||
chain.tail.outputStates.add(chain.head);
|
||||
chain.tail.getOutputStates().add(chain.head);
|
||||
return chain;
|
||||
}
|
||||
|
||||
|
@ -102,10 +103,10 @@ public class Pattern<T> {
|
|||
private PatternChain<T> transformStar(PatternChain<T> chain) {
|
||||
LinkNode<T> newTail = new LinkNode<>();
|
||||
LinkNode<T> newHead = new LinkNode<>();
|
||||
newHead.outputStates.add(chain.head);
|
||||
newHead.outputStates.add(newTail);
|
||||
chain.tail.outputStates.add(newTail);
|
||||
newTail.outputStates.add(newHead);
|
||||
newHead.getOutputStates().add(chain.head);
|
||||
newHead.getOutputStates().add(newTail);
|
||||
chain.tail.getOutputStates().add(newTail);
|
||||
newTail.getOutputStates().add(newHead);
|
||||
chain.head = newHead;
|
||||
chain.tail = newTail;
|
||||
return chain;
|
||||
|
@ -121,9 +122,9 @@ public class Pattern<T> {
|
|||
private PatternChain<T> transformQuestion(PatternChain<T> chain) {
|
||||
LinkNode<T> newTail = new LinkNode<>();
|
||||
LinkNode<T> newHead = new LinkNode<>();
|
||||
newHead.outputStates.add(chain.head);
|
||||
newHead.outputStates.add(newTail);
|
||||
chain.tail.outputStates.add(newTail);
|
||||
newHead.getOutputStates().add(chain.head);
|
||||
newHead.getOutputStates().add(newTail);
|
||||
chain.tail.getOutputStates().add(newTail);
|
||||
chain.head = newHead;
|
||||
chain.tail = newTail;
|
||||
return chain;
|
||||
|
@ -140,8 +141,8 @@ public class Pattern<T> {
|
|||
LinkNode<T> tail = new LinkNode<>();
|
||||
PatternChain<T> newChain = new PatternChain<>(head, tail);
|
||||
for (PatternChain<T> chain : collection) {
|
||||
head.outputStates.add(chain.head);
|
||||
chain.tail.outputStates.add(tail);
|
||||
head.getOutputStates().add(chain.head);
|
||||
chain.tail.getOutputStates().add(tail);
|
||||
}
|
||||
return newChain;
|
||||
}
|
||||
|
@ -205,7 +206,7 @@ public class Pattern<T> {
|
|||
if (operations.containsKey(currentChar)) {
|
||||
if (currentChain == null) return null;
|
||||
|
||||
currentChain = operations.get(currentChar).apply(currentChain);
|
||||
currentChain = operations.get(currentChar).transform(currentChain);
|
||||
fullChain.append(currentChain);
|
||||
currentChain = null;
|
||||
index++;
|
||||
|
|
|
@ -1,5 +1,7 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
|
||||
import org.nwapw.abacus.lexing.pattern.nodes.PatternNode;
|
||||
|
||||
/**
|
||||
* A chain of nodes that can be treated as a single unit.
|
||||
* Used during pattern compilation.
|
||||
|
@ -56,7 +58,7 @@ public class PatternChain<T> {
|
|||
this.head = other.head;
|
||||
this.tail = other.tail;
|
||||
} else {
|
||||
tail.outputStates.add(other.head);
|
||||
tail.getOutputStates().add(other.head);
|
||||
tail = other.tail;
|
||||
}
|
||||
}
|
||||
|
@ -72,7 +74,7 @@ public class PatternChain<T> {
|
|||
if (tail == null) {
|
||||
head = tail = node;
|
||||
} else {
|
||||
tail.outputStates.add(node);
|
||||
tail.getOutputStates().add(node);
|
||||
tail = node;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -0,0 +1,16 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
|
||||
/**
|
||||
* An interface that transforms a pattern chain into a different pattern chain.
|
||||
* @param <T> the type used to identify the nodes in the pattern chain.
|
||||
*/
|
||||
public interface Transformation<T> {
|
||||
|
||||
/**
|
||||
* Performs the actual transformation.
|
||||
* @param from the original chain.
|
||||
* @return the resulting chain.
|
||||
*/
|
||||
PatternChain<T> transform(PatternChain<T> from);
|
||||
|
||||
}
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
package org.nwapw.abacus.lexing.pattern.nodes;
|
||||
|
||||
/**
|
||||
* A pattern node that matches any character.
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
package org.nwapw.abacus.lexing.pattern.nodes;
|
||||
|
||||
/**
|
||||
* A node that represents a successful match.
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
package org.nwapw.abacus.lexing.pattern.nodes;
|
||||
|
||||
import java.util.Collection;
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
package org.nwapw.abacus.lexing.pattern.nodes;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.HashSet;
|
||||
|
@ -65,4 +65,11 @@ public class PatternNode<T> {
|
|||
outputStates.forEach(e -> e.addInto(into));
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the output states of this node.
|
||||
* @return the output states.
|
||||
*/
|
||||
public Set<PatternNode<T>> getOutputStates() {
|
||||
return outputStates;
|
||||
}
|
||||
}
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
package org.nwapw.abacus.lexing.pattern.nodes;
|
||||
|
||||
/**
|
||||
* A node that matches a range of characters.
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.lexing.pattern;
|
||||
package org.nwapw.abacus.lexing.pattern.nodes;
|
||||
|
||||
/**
|
||||
* A node that matches a single value.
|
|
@ -1,4 +1,6 @@
|
|||
package org.nwapw.abacus.number;
|
||||
package org.nwapw.abacus.number.standard;
|
||||
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
|
||||
/**
|
||||
* An implementation of NumberInterface using a double.
|
||||
|
@ -114,15 +116,6 @@ public class NaiveNumber extends NumberInterface {
|
|||
return (int) value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass) {
|
||||
if (toClass == this.getClass()) return this;
|
||||
else if (toClass == PreciseNumber.class) {
|
||||
return new PreciseNumber(Double.toString(value));
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
double shiftBy = Math.pow(10, 10);
|
||||
return Double.toString(Math.round(value * shiftBy) / shiftBy);
|
|
@ -1,4 +1,6 @@
|
|||
package org.nwapw.abacus.number;
|
||||
package org.nwapw.abacus.number.standard;
|
||||
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.math.MathContext;
|
||||
|
@ -152,14 +154,6 @@ public class PreciseNumber extends NumberInterface {
|
|||
return new PreciseNumber(value.negate());
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass) {
|
||||
if (toClass == this.getClass()) {
|
||||
return this;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return value.round(outputContext).toString();
|
|
@ -1,20 +0,0 @@
|
|||
package org.nwapw.abacus.parsing;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Interface that provides the ability to convert a string into a list of tokens.
|
||||
*
|
||||
* @param <T> the type of the tokens produced.
|
||||
*/
|
||||
public interface Tokenizer<T> {
|
||||
|
||||
/**
|
||||
* Converts a string into tokens.
|
||||
*
|
||||
* @param string the string to convert.
|
||||
* @return the list of tokens, or null on error.
|
||||
*/
|
||||
public List<T> tokenizeString(String string);
|
||||
|
||||
}
|
|
@ -1,50 +0,0 @@
|
|||
package org.nwapw.abacus.parsing;
|
||||
|
||||
import org.nwapw.abacus.tree.TreeNode;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* TreeBuilder class used to piece together a Tokenizer and
|
||||
* Parser of the same kind. This is used to essentially avoid
|
||||
* working with any parameters at all, and the generics
|
||||
* in this class are used only to ensure the tokenizer and parser
|
||||
* are of the same type.
|
||||
*
|
||||
* @param <T> the type of tokens created by the tokenizer and used by the parser.
|
||||
*/
|
||||
public class TreeBuilder<T> {
|
||||
|
||||
/**
|
||||
* The tokenizer used to convert a string into tokens.
|
||||
*/
|
||||
private Tokenizer<T> tokenizer;
|
||||
/**
|
||||
* The parser used to parse a list of tokens into a tree.
|
||||
*/
|
||||
private Parser<T> parser;
|
||||
|
||||
/**
|
||||
* Create a new Tree Builder with the given tokenizer and parser
|
||||
*
|
||||
* @param tokenizer the tokenizer to turn strings into tokens
|
||||
* @param parser the parser to turn tokens into a tree
|
||||
*/
|
||||
public TreeBuilder(Tokenizer<T> tokenizer, Parser<T> parser) {
|
||||
this.tokenizer = tokenizer;
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the given string into a tree.
|
||||
*
|
||||
* @param input the string to parse into a tree.
|
||||
* @return the resulting tree.
|
||||
*/
|
||||
public TreeNode fromString(String input) {
|
||||
List<T> tokens = tokenizer.tokenizeString(input);
|
||||
if (tokens == null) return null;
|
||||
return parser.constructTree(tokens);
|
||||
}
|
||||
|
||||
}
|
|
@ -1,11 +1,12 @@
|
|||
package org.nwapw.abacus.parsing;
|
||||
package org.nwapw.abacus.parsing.standard;
|
||||
|
||||
import org.nwapw.abacus.exception.TokenizeException;
|
||||
import org.nwapw.abacus.lexing.Lexer;
|
||||
import org.nwapw.abacus.lexing.pattern.Match;
|
||||
import org.nwapw.abacus.lexing.Match;
|
||||
import org.nwapw.abacus.lexing.pattern.Pattern;
|
||||
import org.nwapw.abacus.parsing.Tokenizer;
|
||||
import org.nwapw.abacus.plugin.PluginListener;
|
||||
import org.nwapw.abacus.plugin.PluginManager;
|
||||
import org.nwapw.abacus.tree.TokenType;
|
||||
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
|
@ -19,7 +20,7 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
|
|||
/**
|
||||
* Comparator used to sort the tokens produced by the lexer.
|
||||
*/
|
||||
protected static final Comparator<TokenType> TOKEN_SORTER = Comparator.comparingInt(e -> e.priority);
|
||||
protected static final Comparator<TokenType> TOKEN_SORTER = (o1, o2) -> o1.priority - o2.priority;
|
||||
|
||||
/**
|
||||
* The lexer instance used to turn strings into matches.
|
||||
|
@ -34,6 +35,7 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
|
|||
register(" ", TokenType.WHITESPACE);
|
||||
register(",", TokenType.COMMA);
|
||||
register("[0-9]*(\\.[0-9]+)?", TokenType.NUM);
|
||||
register("[a-zA-Z]+", TokenType.VARIABLE);
|
||||
register("\\(", TokenType.OPEN_PARENTH);
|
||||
register("\\)", TokenType.CLOSE_PARENTH);
|
||||
}};
|
||||
|
@ -41,7 +43,9 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
|
|||
|
||||
@Override
|
||||
public List<Match<TokenType>> tokenizeString(String string) {
|
||||
return lexer.lexAll(string, 0, TOKEN_SORTER);
|
||||
List<Match<TokenType>> tokens = lexer.lexAll(string, 0, TOKEN_SORTER);
|
||||
if(tokens == null) throw new TokenizeException();
|
||||
return tokens;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -49,9 +53,15 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
|
|||
for (String operator : manager.getAllOperators()) {
|
||||
lexer.register(Pattern.sanitize(operator), TokenType.OP);
|
||||
}
|
||||
for (String operator : manager.getAllTreeValueOperators()) {
|
||||
lexer.register(Pattern.sanitize(operator), TokenType.TREE_VALUE_OP);
|
||||
}
|
||||
for (String function : manager.getAllFunctions()) {
|
||||
lexer.register(Pattern.sanitize(function), TokenType.FUNCTION);
|
||||
}
|
||||
for (String function : manager.getAllTreeValueFunctions()) {
|
||||
lexer.register(Pattern.sanitize(function), TokenType.TREE_VALUE_FUNCTION);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -59,9 +69,15 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
|
|||
for (String operator : manager.getAllOperators()) {
|
||||
lexer.unregister(Pattern.sanitize(operator), TokenType.OP);
|
||||
}
|
||||
for (String operator : manager.getAllTreeValueOperators()) {
|
||||
lexer.unregister(Pattern.sanitize(operator), TokenType.TREE_VALUE_OP);
|
||||
}
|
||||
for (String function : manager.getAllFunctions()) {
|
||||
lexer.unregister(Pattern.sanitize(function), TokenType.FUNCTION);
|
||||
}
|
||||
for (String function : manager.getAllTreeValueFunctions()) {
|
||||
lexer.unregister(Pattern.sanitize(function), TokenType.TREE_VALUE_FUNCTION);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
|
@ -1,13 +1,14 @@
|
|||
package org.nwapw.abacus.parsing;
|
||||
package org.nwapw.abacus.parsing.standard;
|
||||
|
||||
import org.nwapw.abacus.Abacus;
|
||||
import org.nwapw.abacus.exception.ParseException;
|
||||
import org.nwapw.abacus.function.Operator;
|
||||
import org.nwapw.abacus.function.OperatorAssociativity;
|
||||
import org.nwapw.abacus.function.OperatorType;
|
||||
import org.nwapw.abacus.lexing.pattern.Match;
|
||||
import org.nwapw.abacus.lexing.Match;
|
||||
import org.nwapw.abacus.parsing.Parser;
|
||||
import org.nwapw.abacus.plugin.PluginListener;
|
||||
import org.nwapw.abacus.plugin.PluginManager;
|
||||
import org.nwapw.abacus.tree.*;
|
||||
import org.nwapw.abacus.tree.nodes.*;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
|
@ -17,10 +18,6 @@ import java.util.*;
|
|||
*/
|
||||
public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListener {
|
||||
|
||||
/**
|
||||
* The Abacus instance used to create number instances.
|
||||
*/
|
||||
private Abacus abacus;
|
||||
/**
|
||||
* Map of operator precedences, loaded from the plugin operators.
|
||||
*/
|
||||
|
@ -35,12 +32,9 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
|
|||
private Map<String, OperatorType> typeMap;
|
||||
|
||||
/**
|
||||
* Creates a new Shunting Yard parser with the given Abacus instance.
|
||||
*
|
||||
* @param abacus the abacus instance.
|
||||
* Creates a new Shunting Yard parser.
|
||||
*/
|
||||
public ShuntingYardParser(Abacus abacus) {
|
||||
this.abacus = abacus;
|
||||
public ShuntingYardParser() {
|
||||
precedenceMap = new HashMap<>();
|
||||
associativityMap = new HashMap<>();
|
||||
typeMap = new HashMap<>();
|
||||
|
@ -61,12 +55,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
|
|||
Match<TokenType> match = from.remove(0);
|
||||
previousType = matchType;
|
||||
matchType = match.getType();
|
||||
if (matchType == TokenType.NUM) {
|
||||
if (matchType == TokenType.NUM || matchType == TokenType.VARIABLE) {
|
||||
output.add(match);
|
||||
} else if (matchType == TokenType.FUNCTION) {
|
||||
} else if (matchType == TokenType.FUNCTION || matchType == TokenType.TREE_VALUE_FUNCTION) {
|
||||
output.add(new Match<>("", TokenType.INTERNAL_FUNCTION_END));
|
||||
tokenStack.push(match);
|
||||
} else if (matchType == TokenType.OP) {
|
||||
} else if (matchType == TokenType.OP || matchType == TokenType.TREE_VALUE_OP) {
|
||||
String tokenString = match.getContent();
|
||||
OperatorType type = typeMap.get(tokenString);
|
||||
int precedence = precedenceMap.get(tokenString);
|
||||
|
@ -78,7 +72,7 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
|
|||
}
|
||||
|
||||
if (tokenString.equals("-") && (previousType == null || previousType == TokenType.OP ||
|
||||
previousType == TokenType.OPEN_PARENTH)) {
|
||||
previousType == TokenType.TREE_VALUE_OP || previousType == TokenType.OPEN_PARENTH)) {
|
||||
from.add(0, new Match<>("`", TokenType.OP));
|
||||
continue;
|
||||
}
|
||||
|
@ -86,9 +80,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
|
|||
while (!tokenStack.empty() && type == OperatorType.BINARY_INFIX) {
|
||||
Match<TokenType> otherMatch = tokenStack.peek();
|
||||
TokenType otherMatchType = otherMatch.getType();
|
||||
if (!(otherMatchType == TokenType.OP || otherMatchType == TokenType.FUNCTION)) break;
|
||||
if (!(otherMatchType == TokenType.OP ||
|
||||
otherMatchType == TokenType.TREE_VALUE_OP ||
|
||||
otherMatchType == TokenType.FUNCTION ||
|
||||
otherMatchType == TokenType.TREE_VALUE_FUNCTION)) break;
|
||||
|
||||
if (otherMatchType == TokenType.OP) {
|
||||
if (otherMatchType == TokenType.OP || otherMatchType == TokenType.TREE_VALUE_OP) {
|
||||
int otherPrecedence = precedenceMap.get(otherMatch.getContent());
|
||||
if (otherPrecedence < precedence ||
|
||||
(associativity == OperatorAssociativity.RIGHT && otherPrecedence == precedence)) {
|
||||
|
@ -104,7 +101,7 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
|
|||
while (!tokenStack.empty() && tokenStack.peek().getType() != TokenType.OPEN_PARENTH) {
|
||||
output.add(tokenStack.pop());
|
||||
}
|
||||
if (tokenStack.empty()) return null;
|
||||
if (tokenStack.empty()) throw new ParseException("mismatched parentheses");
|
||||
if (matchType == TokenType.CLOSE_PARENTH) {
|
||||
tokenStack.pop();
|
||||
}
|
||||
|
@ -113,7 +110,10 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
|
|||
while (!tokenStack.empty()) {
|
||||
Match<TokenType> match = tokenStack.peek();
|
||||
TokenType newMatchType = match.getType();
|
||||
if (!(newMatchType == TokenType.OP || newMatchType == TokenType.FUNCTION)) return null;
|
||||
if (!(newMatchType == TokenType.OP ||
|
||||
newMatchType == TokenType.TREE_VALUE_OP ||
|
||||
newMatchType == TokenType.FUNCTION ||
|
||||
newMatchType == TokenType.TREE_VALUE_FUNCTION)) throw new ParseException("mismatched parentheses");
|
||||
output.add(tokenStack.pop());
|
||||
}
|
||||
return output;
|
||||
|
@ -125,47 +125,61 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
|
|||
* @param matches the list of tokens from the source string.
|
||||
* @return the construct tree expression.
|
||||
*/
|
||||
public TreeNode constructRecursive(List<Match<TokenType>> matches) {
|
||||
if (matches.size() == 0) return null;
|
||||
public TreeNode constructRecursive(List<? extends Match<TokenType>> matches) {
|
||||
if (matches.size() == 0) throw new ParseException("no tokens left in input");
|
||||
Match<TokenType> match = matches.remove(0);
|
||||
TokenType matchType = match.getType();
|
||||
if (matchType == TokenType.OP) {
|
||||
if (matchType == TokenType.OP || matchType == TokenType.TREE_VALUE_OP) {
|
||||
String operator = match.getContent();
|
||||
OperatorType type = typeMap.get(operator);
|
||||
if (type == OperatorType.BINARY_INFIX) {
|
||||
TreeNode right = constructRecursive(matches);
|
||||
TreeNode left = constructRecursive(matches);
|
||||
if (left == null || right == null) return null;
|
||||
else return new BinaryNode(operator, left, right);
|
||||
if (matchType == TokenType.OP) {
|
||||
return new NumberBinaryNode(operator, left, right);
|
||||
} else {
|
||||
return new TreeValueBinaryNode(operator, left, right);
|
||||
}
|
||||
} else {
|
||||
TreeNode applyTo = constructRecursive(matches);
|
||||
if (applyTo == null) return null;
|
||||
else return new UnaryNode(operator, applyTo);
|
||||
if (matchType == TokenType.OP) {
|
||||
return new NumberUnaryNode(operator, applyTo);
|
||||
} else {
|
||||
return new TreeValueUnaryNode(operator, applyTo);
|
||||
}
|
||||
}
|
||||
} else if (matchType == TokenType.NUM) {
|
||||
return new NumberNode(abacus.numberFromString(match.getContent()));
|
||||
} else if (matchType == TokenType.FUNCTION) {
|
||||
return new NumberNode(match.getContent());
|
||||
} else if (matchType == TokenType.VARIABLE) {
|
||||
return new VariableNode(match.getContent());
|
||||
} else if (matchType == TokenType.FUNCTION || matchType == TokenType.TREE_VALUE_FUNCTION) {
|
||||
String functionName = match.getContent();
|
||||
FunctionNode node = new FunctionNode(functionName);
|
||||
List<TreeNode> children = new ArrayList<>();
|
||||
while (!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END) {
|
||||
TreeNode argument = constructRecursive(matches);
|
||||
if (argument == null) return null;
|
||||
node.prependChild(argument);
|
||||
children.add(0, argument);
|
||||
}
|
||||
if (matches.isEmpty()) return null;
|
||||
if (matches.isEmpty()) throw new ParseException("incorrectly formatted function call");
|
||||
matches.remove(0);
|
||||
CallNode node;
|
||||
if (matchType == TokenType.FUNCTION) {
|
||||
node = new NumberFunctionNode(functionName, children);
|
||||
} else {
|
||||
node = new TreeValueFunctionNode(functionName, children);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
return null;
|
||||
throw new ParseException("unrecognized token");
|
||||
}
|
||||
|
||||
@Override
|
||||
public TreeNode constructTree(List<Match<TokenType>> tokens) {
|
||||
public TreeNode constructTree(List<? extends Match<TokenType>> tokens) {
|
||||
if (tokens.isEmpty()) throw new ParseException("no input tokens");
|
||||
tokens = intoPostfix(new ArrayList<>(tokens));
|
||||
if (tokens == null) return null;
|
||||
Collections.reverse(tokens);
|
||||
TreeNode constructedTree = constructRecursive(tokens);
|
||||
return tokens.size() == 0 ? constructedTree : null;
|
||||
if(tokens.size() == 0) return constructedTree;
|
||||
throw new ParseException("could not parse all input");
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -176,6 +190,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
|
|||
associativityMap.put(operator, operatorInstance.getAssociativity());
|
||||
typeMap.put(operator, operatorInstance.getType());
|
||||
}
|
||||
for (String operator : manager.getAllTreeValueOperators()) {
|
||||
Operator operatorInstance = manager.treeValueOperatorFor(operator);
|
||||
precedenceMap.put(operator, operatorInstance.getPrecedence());
|
||||
associativityMap.put(operator, operatorInstance.getAssociativity());
|
||||
typeMap.put(operator, operatorInstance.getType());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.tree;
|
||||
package org.nwapw.abacus.parsing.standard;
|
||||
|
||||
/**
|
||||
* Enum to represent the type of the token that has been matched
|
||||
|
@ -7,7 +7,8 @@ package org.nwapw.abacus.tree;
|
|||
public enum TokenType {
|
||||
|
||||
INTERNAL_FUNCTION_END(-1),
|
||||
ANY(0), WHITESPACE(1), COMMA(2), OP(3), NUM(4), FUNCTION(5), OPEN_PARENTH(6), CLOSE_PARENTH(7);
|
||||
ANY(0), WHITESPACE(1), COMMA(2), VARIABLE(3), OP(4), TREE_VALUE_OP(4),
|
||||
NUM(5), FUNCTION(6), TREE_VALUE_FUNCTION(6), OPEN_PARENTH(7), CLOSE_PARENTH(7);
|
||||
|
||||
/**
|
||||
* The priority by which this token gets sorted.
|
|
@ -1,10 +1,10 @@
|
|||
package org.nwapw.abacus.plugin;
|
||||
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
import org.nwapw.abacus.number.promotion.PromotionFunction;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.function.Function;
|
||||
|
||||
/**
|
||||
* A class that holds data about a number implementation.
|
||||
|
@ -14,7 +14,7 @@ public abstract class NumberImplementation {
|
|||
/**
|
||||
* The list of paths through which this implementation can be promoted.
|
||||
*/
|
||||
private Map<Class<? extends NumberInterface>, Function<NumberInterface, NumberInterface>> promotionPaths;
|
||||
private Map<String, PromotionFunction> promotionPaths;
|
||||
/**
|
||||
* The implementation class for this implementation.
|
||||
*/
|
||||
|
@ -41,7 +41,7 @@ public abstract class NumberImplementation {
|
|||
*
|
||||
* @return the map of documentation paths.
|
||||
*/
|
||||
public final Map<Class<? extends NumberInterface>, Function<NumberInterface, NumberInterface>> getPromotionPaths() {
|
||||
public final Map<String, PromotionFunction> getPromotionPaths() {
|
||||
return promotionPaths;
|
||||
}
|
||||
|
||||
|
|
|
@ -2,8 +2,10 @@ package org.nwapw.abacus.plugin;
|
|||
|
||||
import org.nwapw.abacus.function.Documentation;
|
||||
import org.nwapw.abacus.function.DocumentationType;
|
||||
import org.nwapw.abacus.function.Function;
|
||||
import org.nwapw.abacus.function.Operator;
|
||||
import org.nwapw.abacus.function.interfaces.NumberFunction;
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator;
|
||||
import org.nwapw.abacus.function.interfaces.TreeValueFunction;
|
||||
import org.nwapw.abacus.function.interfaces.TreeValueOperator;
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
|
||||
/**
|
||||
|
@ -65,10 +67,21 @@ public abstract class Plugin {
|
|||
* @param name the name to register by.
|
||||
* @param toRegister the function implementation.
|
||||
*/
|
||||
protected final void registerFunction(String name, Function toRegister) {
|
||||
protected final void registerFunction(String name, NumberFunction toRegister) {
|
||||
manager.registerFunction(name, toRegister);
|
||||
}
|
||||
|
||||
/**
|
||||
* To be used in load(). Registers a tree value function abstract class
|
||||
* with the plugin internally, which makes it accessible to the plugin manager.
|
||||
*
|
||||
* @param name the name to register by.
|
||||
* @param toRegister the tree value function implementation.
|
||||
*/
|
||||
protected final void registerTreeValueFunction(String name, TreeValueFunction toRegister) {
|
||||
manager.registerTreeValueFunction(name, toRegister);
|
||||
}
|
||||
|
||||
/**
|
||||
* To be used in load(). Registers an operator abstract class
|
||||
* with the plugin internally, which makes it accessible to
|
||||
|
@ -77,10 +90,22 @@ public abstract class Plugin {
|
|||
* @param name the name of the operator.
|
||||
* @param operator the operator to register.
|
||||
*/
|
||||
protected final void registerOperator(String name, Operator operator) {
|
||||
protected final void registerOperator(String name, NumberOperator operator) {
|
||||
manager.registerOperator(name, operator);
|
||||
}
|
||||
|
||||
/**
|
||||
* To be used in load(). Registers an operator
|
||||
* with the plugin internally, which makes it accessible
|
||||
* to the plugin manager.
|
||||
*
|
||||
* @param name the name of the tree value operator.
|
||||
* @param operator the tree value operator to register.
|
||||
*/
|
||||
protected final void registerTreeValueOperator(String name, TreeValueOperator operator) {
|
||||
manager.registerTreeValueOperator(name, operator);
|
||||
}
|
||||
|
||||
/**
|
||||
* To be used in load(). Registers a new number implementation with the plugin.
|
||||
* This makes it accessible to the plugin manager.
|
||||
|
@ -110,10 +135,22 @@ public abstract class Plugin {
|
|||
* @param name the name for which to search
|
||||
* @return the resulting function, or null if none was found for that name.
|
||||
*/
|
||||
protected final Function functionFor(String name) {
|
||||
protected final NumberFunction functionFor(String name) {
|
||||
return manager.functionFor(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Searches the PluginManager for the given function name.
|
||||
* This can be used by the plugins internally in order to call functions
|
||||
* they do not provide.
|
||||
*
|
||||
* @param name the name for which to search.
|
||||
* @return the resulting tree value function, or null if none was found for that name.
|
||||
*/
|
||||
protected final TreeValueFunction treeValueFunctionFor(String name) {
|
||||
return manager.treeValueFunctionFor(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Searches the PluginManager for the given operator name.
|
||||
* This can be used by the plugins internally in order to call
|
||||
|
@ -122,10 +159,22 @@ public abstract class Plugin {
|
|||
* @param name the name for which to search
|
||||
* @return the resulting operator, or null if none was found for that name.
|
||||
*/
|
||||
protected final Operator operatorFor(String name) {
|
||||
protected final NumberOperator operatorFor(String name) {
|
||||
return manager.operatorFor(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Searches the PluginManager for the given tree value operator name.
|
||||
* This can be used by the plugins internally in order to call
|
||||
* operations they do not provide.
|
||||
*
|
||||
* @param name the name for which to search.
|
||||
* @return the resulting tree value operator, or null if none was found for that name.
|
||||
*/
|
||||
protected final TreeValueOperator treeValueOperatorFor(String name) {
|
||||
return manager.treeValueOperatorFor(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Searches the PluginManager for the given number implementation
|
||||
* name. This can be used by the plugins internally in order to find
|
||||
|
|
|
@ -3,8 +3,10 @@ package org.nwapw.abacus.plugin;
|
|||
import org.nwapw.abacus.Abacus;
|
||||
import org.nwapw.abacus.function.Documentation;
|
||||
import org.nwapw.abacus.function.DocumentationType;
|
||||
import org.nwapw.abacus.function.Function;
|
||||
import org.nwapw.abacus.function.Operator;
|
||||
import org.nwapw.abacus.function.interfaces.NumberFunction;
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator;
|
||||
import org.nwapw.abacus.function.interfaces.TreeValueFunction;
|
||||
import org.nwapw.abacus.function.interfaces.TreeValueOperator;
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
|
@ -30,11 +32,19 @@ public class PluginManager {
|
|||
/**
|
||||
* The map of functions registered by the plugins.
|
||||
*/
|
||||
private Map<String, Function> registeredFunctions;
|
||||
private Map<String, NumberFunction> registeredFunctions;
|
||||
/**
|
||||
* The map of tree value functions regstered by the plugins.
|
||||
*/
|
||||
private Map<String, TreeValueFunction> registeredTreeValueFunctions;
|
||||
/**
|
||||
* The map of operators registered by the plugins
|
||||
*/
|
||||
private Map<String, Operator> registeredOperators;
|
||||
private Map<String, NumberOperator> registeredOperators;
|
||||
/**
|
||||
* The map of tree value operators registered by the plugins.
|
||||
*/
|
||||
private Map<String, TreeValueOperator> registeredTreeValueOperators;
|
||||
/**
|
||||
* The map of number implementations registered by the plugins.
|
||||
*/
|
||||
|
@ -44,10 +54,13 @@ public class PluginManager {
|
|||
*/
|
||||
private Set<Documentation> registeredDocumentation;
|
||||
/**
|
||||
* The list of number implementations that have been
|
||||
* found by their implementation class.
|
||||
* The list of number implementation names.
|
||||
*/
|
||||
private Map<Class<? extends NumberInterface>, NumberImplementation> cachedInterfaceImplementations;
|
||||
private Map<Class<? extends NumberInterface>, String> interfaceImplementationNames;
|
||||
/**
|
||||
* The list of number implementations.
|
||||
*/
|
||||
private Map<Class<? extends NumberInterface>, NumberImplementation> interfaceImplementations;
|
||||
/**
|
||||
* The pi values for each implementation class that have already been computer.
|
||||
*/
|
||||
|
@ -72,10 +85,13 @@ public class PluginManager {
|
|||
loadedPluginClasses = new HashSet<>();
|
||||
plugins = new HashSet<>();
|
||||
registeredFunctions = new HashMap<>();
|
||||
registeredTreeValueFunctions = new HashMap<>();
|
||||
registeredOperators = new HashMap<>();
|
||||
registeredTreeValueOperators = new HashMap<>();
|
||||
registeredNumberImplementations = new HashMap<>();
|
||||
registeredDocumentation = new HashSet<>();
|
||||
cachedInterfaceImplementations = new HashMap<>();
|
||||
interfaceImplementations = new HashMap<>();
|
||||
interfaceImplementationNames = new HashMap<>();
|
||||
cachedPi = new HashMap<>();
|
||||
listeners = new HashSet<>();
|
||||
}
|
||||
|
@ -86,20 +102,40 @@ public class PluginManager {
|
|||
* @param name the name of the function.
|
||||
* @param function the function to register.
|
||||
*/
|
||||
public void registerFunction(String name, Function function) {
|
||||
public void registerFunction(String name, NumberFunction function) {
|
||||
registeredFunctions.put(name, function);
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a tree value function under the given name.
|
||||
*
|
||||
* @param name the name of the function.
|
||||
* @param function the function to register.
|
||||
*/
|
||||
public void registerTreeValueFunction(String name, TreeValueFunction function) {
|
||||
registeredTreeValueFunctions.put(name, function);
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers an operator under the given name.
|
||||
*
|
||||
* @param name the name of the operator.
|
||||
* @param operator the operator to register.
|
||||
*/
|
||||
public void registerOperator(String name, Operator operator) {
|
||||
public void registerOperator(String name, NumberOperator operator) {
|
||||
registeredOperators.put(name, operator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a tree value operator under the given name.
|
||||
*
|
||||
* @param name the name of the tree value operator.
|
||||
* @param operator the tree value operator to register.
|
||||
*/
|
||||
public void registerTreeValueOperator(String name, TreeValueOperator operator) {
|
||||
registeredTreeValueOperators.put(name, operator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a number implementation under the given name.
|
||||
*
|
||||
|
@ -108,6 +144,9 @@ public class PluginManager {
|
|||
*/
|
||||
public void registerNumberImplementation(String name, NumberImplementation implementation) {
|
||||
registeredNumberImplementations.put(name, implementation);
|
||||
interfaceImplementationNames.put(implementation.getImplementation(), name);
|
||||
interfaceImplementations.put(implementation.getImplementation(), implementation);
|
||||
cachedPi.put(implementation.getImplementation(), implementation.instanceForPi());
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -126,20 +165,40 @@ public class PluginManager {
|
|||
* @param name the name of the function.
|
||||
* @return the function, or null if it was not found.
|
||||
*/
|
||||
public Function functionFor(String name) {
|
||||
public NumberFunction functionFor(String name) {
|
||||
return registeredFunctions.get(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the tree value function registered under the given name.
|
||||
*
|
||||
* @param name the name of the function.
|
||||
* @return the function, or null if it was not found.
|
||||
*/
|
||||
public TreeValueFunction treeValueFunctionFor(String name) {
|
||||
return registeredTreeValueFunctions.get(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operator registered under the given name.
|
||||
*
|
||||
* @param name the name of the operator.
|
||||
* @return the operator, or null if it was not found.
|
||||
*/
|
||||
public Operator operatorFor(String name) {
|
||||
public NumberOperator operatorFor(String name) {
|
||||
return registeredOperators.get(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the tree value operator registered under the given name.
|
||||
*
|
||||
* @param name the name of the tree value operator.
|
||||
* @return the operator, or null if it was not found.
|
||||
*/
|
||||
public TreeValueOperator treeValueOperatorFor(String name) {
|
||||
return registeredTreeValueOperators.get(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the number implementation registered under the given name.
|
||||
*
|
||||
|
@ -165,10 +224,6 @@ public class PluginManager {
|
|||
break;
|
||||
}
|
||||
}
|
||||
if (toReturn == null) {
|
||||
toReturn = new Documentation(name, "", "", "", type);
|
||||
registerDocumentation(toReturn);
|
||||
}
|
||||
return toReturn;
|
||||
}
|
||||
|
||||
|
@ -179,17 +234,17 @@ public class PluginManager {
|
|||
* @return the implementation.
|
||||
*/
|
||||
public NumberImplementation interfaceImplementationFor(Class<? extends NumberInterface> name) {
|
||||
if (cachedInterfaceImplementations.containsKey(name)) return cachedInterfaceImplementations.get(name);
|
||||
NumberImplementation toReturn = null;
|
||||
for (String key : registeredNumberImplementations.keySet()) {
|
||||
NumberImplementation implementation = registeredNumberImplementations.get(key);
|
||||
if (implementation.getImplementation() == name) {
|
||||
toReturn = implementation;
|
||||
break;
|
||||
}
|
||||
}
|
||||
cachedInterfaceImplementations.put(name, toReturn);
|
||||
return toReturn;
|
||||
return interfaceImplementations.get(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the number implementation name for the given implementation class.
|
||||
*
|
||||
* @param name the class for which to find the implementation name.
|
||||
* @return the implementation name.
|
||||
*/
|
||||
public String interfaceImplementationNameFor(Class<? extends NumberInterface> name) {
|
||||
return interfaceImplementationNames.get(name);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -199,14 +254,7 @@ public class PluginManager {
|
|||
* @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;
|
||||
return cachedPi.get(forClass);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -277,10 +325,13 @@ public class PluginManager {
|
|||
plugin.disable();
|
||||
}
|
||||
registeredFunctions.clear();
|
||||
registeredTreeValueFunctions.clear();
|
||||
registeredOperators.clear();
|
||||
registeredTreeValueOperators.clear();
|
||||
registeredNumberImplementations.clear();
|
||||
registeredDocumentation.clear();
|
||||
cachedInterfaceImplementations.clear();
|
||||
interfaceImplementationNames.clear();
|
||||
interfaceImplementations.clear();
|
||||
cachedPi.clear();
|
||||
listeners.forEach(e -> e.onUnload(this));
|
||||
}
|
||||
|
@ -302,6 +353,15 @@ public class PluginManager {
|
|||
return registeredFunctions.keySet();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets all the tree vlaue functions loaded by the PluginManager.
|
||||
*
|
||||
* @return the set of all the tree value functions that were loaded.
|
||||
*/
|
||||
public Set<String> getAllTreeValueFunctions() {
|
||||
return registeredTreeValueFunctions.keySet();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets all the operators loaded by the Plugin Manager.
|
||||
*
|
||||
|
@ -311,6 +371,15 @@ public class PluginManager {
|
|||
return registeredOperators.keySet();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets all the tree value operators loaded by the PluginManager.
|
||||
*
|
||||
* @return the set of all tree value operators that were loaded.
|
||||
*/
|
||||
public Set<String> getAllTreeValueOperators() {
|
||||
return registeredTreeValueOperators.keySet();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets all the number implementations loaded by the Plugin Manager.
|
||||
*
|
||||
|
@ -347,4 +416,5 @@ public class PluginManager {
|
|||
public Set<Class<?>> getLoadedPluginClasses() {
|
||||
return loadedPluginClasses;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -1,837 +0,0 @@
|
|||
package org.nwapw.abacus.plugin;
|
||||
|
||||
import 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.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.function.BiFunction;
|
||||
|
||||
/**
|
||||
* The plugin providing standard functions such as addition and subtraction to
|
||||
* the calculator.
|
||||
*/
|
||||
public class StandardPlugin extends Plugin {
|
||||
|
||||
/**
|
||||
* The addition operator, +
|
||||
*/
|
||||
public static final Operator OP_ADD = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length >= 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
NumberInterface sum = params[0];
|
||||
for (int i = 1; i < params.length; i++) {
|
||||
sum = sum.add(params[i]);
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
});
|
||||
/**
|
||||
* The subtraction operator, -
|
||||
*/
|
||||
public static final Operator OP_SUBTRACT = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 2;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return params[0].subtract(params[1]);
|
||||
|
||||
}
|
||||
});
|
||||
/**
|
||||
* The negation operator, -
|
||||
*/
|
||||
public static final Operator OP_NEGATE = new Operator(OperatorAssociativity.LEFT, OperatorType.UNARY_PREFIX, 0, new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return params[0].negate();
|
||||
}
|
||||
});
|
||||
/**
|
||||
* The multiplication operator, *
|
||||
*/
|
||||
public static final Operator OP_MULTIPLY = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1, new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length >= 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
NumberInterface product = params[0];
|
||||
for (int i = 1; i < params.length; i++) {
|
||||
product = product.multiply(params[i]);
|
||||
}
|
||||
return product;
|
||||
}
|
||||
});
|
||||
/**
|
||||
* The combination operator.
|
||||
*/
|
||||
public static final Operator OP_NCR = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0, new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 2 && params[0].fractionalPart().signum() == 0
|
||||
&& params[1].fractionalPart().signum() == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return OP_NPR.getFunction().apply(params).divide(OP_FACTORIAL.getFunction().apply(params[1]));
|
||||
}
|
||||
});
|
||||
/**
|
||||
* 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 PreciseNumber((12 * i + 2) + ""))
|
||||
.multiply(new PreciseNumber((12 * i + 6) + ""))
|
||||
.multiply(new PreciseNumber((12 * i + 10) + ""))
|
||||
.divide(new PreciseNumber(Math.pow(i + 1, 3) + ""));
|
||||
L = L.add(lSummand);
|
||||
X = X.multiply(xMultiplier);
|
||||
sum = sum.add(M.multiply(L).divide(X));
|
||||
}
|
||||
return C.divide(sum);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Stores objects of NumberInterface with integer values for reuse.
|
||||
*/
|
||||
private final static HashMap<Class<? extends NumberInterface>, HashMap<Integer, NumberInterface>> integerValues = new HashMap<>();
|
||||
/**
|
||||
* The division operator, /
|
||||
*/
|
||||
public static final Operator OP_DIVIDE = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1, new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 2 && params[1].compareTo(fromInt(params[0].getClass(), 0)) != 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return params[0].divide(params[1]);
|
||||
}
|
||||
});
|
||||
/**
|
||||
* The factorial operator, !
|
||||
*/
|
||||
public static final Operator OP_FACTORIAL = new Operator(OperatorAssociativity.RIGHT, OperatorType.UNARY_POSTFIX, 0, new Function() {
|
||||
//private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1
|
||||
&& params[0].fractionalPart().compareTo(fromInt(params[0].getClass(), 0)) == 0
|
||||
&& params[0].signum() >= 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
if (params[0].signum() == 0) {
|
||||
return fromInt(params[0].getClass(), 1);
|
||||
}
|
||||
NumberInterface one = fromInt(params[0].getClass(), 1);
|
||||
NumberInterface factorial = params[0];
|
||||
NumberInterface multiplier = params[0];
|
||||
//It is necessary to later prevent calls of factorial on anything but non-negative integers.
|
||||
while ((multiplier = multiplier.subtract(one)).signum() == 1) {
|
||||
factorial = factorial.multiply(multiplier);
|
||||
}
|
||||
return factorial;
|
||||
/*if(!storedList.containsKey(params[0].getClass())){
|
||||
storedList.put(params[0].getClass(), new ArrayList<NumberInterface>());
|
||||
storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
|
||||
storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
|
||||
}*/
|
||||
}
|
||||
});
|
||||
/**
|
||||
* The permutation operator.
|
||||
*/
|
||||
public static final Operator OP_NPR = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0, new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 2 && params[0].fractionalPart().signum() == 0
|
||||
&& params[1].fractionalPart().signum() == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
if (params[0].compareTo(params[1]) < 0 ||
|
||||
params[0].signum() < 0 ||
|
||||
(params[0].signum() == 0 && params[1].signum() != 0)) return fromInt(params[0].getClass(), 0);
|
||||
NumberInterface total = fromInt(params[0].getClass(), 1);
|
||||
NumberInterface multiplyBy = params[0];
|
||||
NumberInterface remainingMultiplications = params[1];
|
||||
NumberInterface halfway = params[0].divide(fromInt(params[0].getClass(), 2));
|
||||
if (remainingMultiplications.compareTo(halfway) > 0) {
|
||||
remainingMultiplications = params[0].subtract(remainingMultiplications);
|
||||
}
|
||||
while (remainingMultiplications.signum() > 0) {
|
||||
total = total.multiply(multiplyBy);
|
||||
remainingMultiplications = remainingMultiplications.subtract(fromInt(params[0].getClass(), 1));
|
||||
multiplyBy = multiplyBy.subtract(fromInt(params[0].getClass(), 1));
|
||||
}
|
||||
return total;
|
||||
}
|
||||
});
|
||||
/**
|
||||
* The absolute value function, abs(-3) = 3
|
||||
*/
|
||||
public static final Function FUNCTION_ABS = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return params[0].multiply(fromInt(params[0].getClass(), params[0].signum()));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The natural log function.
|
||||
*/
|
||||
public static final Function FUNCTION_LN = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1 && params[0].compareTo(fromInt(params[0].getClass(), 0)) > 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
NumberInterface param = params[0];
|
||||
NumberInterface one = fromInt(param.getClass(), 1);
|
||||
int powersOf2 = 0;
|
||||
while (FUNCTION_ABS.apply(param.subtract(one)).compareTo(new NaiveNumber(0.1).promoteTo(param.getClass())) >= 0) {
|
||||
if (param.subtract(one).signum() == 1) {
|
||||
param = param.divide(fromInt(param.getClass(), 2));
|
||||
powersOf2++;
|
||||
if (param.subtract(one).signum() != 1) {
|
||||
break;
|
||||
//No infinite loop for you.
|
||||
}
|
||||
} else {
|
||||
param = param.multiply(fromInt(param.getClass(), 2));
|
||||
powersOf2--;
|
||||
if (param.subtract(one).signum() != -1) {
|
||||
break;
|
||||
//No infinite loop for you.
|
||||
}
|
||||
}
|
||||
}
|
||||
return getLog2(param).multiply(fromInt(param.getClass(), powersOf2)).add(getLogPartialSum(param));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the partial sum of the Taylor series for logx (around x=1).
|
||||
* Automatically determines the number of terms needed based on the precision of x.
|
||||
* @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(NumberInterface x) {
|
||||
|
||||
NumberInterface maxError = x.getMaxError();
|
||||
x = x.subtract(fromInt(x.getClass(), 1)); //Terms used are for log(x+1).
|
||||
NumberInterface currentNumerator = x, currentTerm = x, sum = x;
|
||||
int n = 1;
|
||||
while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0) {
|
||||
n++;
|
||||
currentNumerator = currentNumerator.multiply(x).negate();
|
||||
currentTerm = currentNumerator.divide(fromInt(x.getClass(), n));
|
||||
sum = sum.add(currentTerm);
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns natural log of 2 to the required precision of the class of number.
|
||||
* @param number a number of the same type as the return type. (Used for precision.)
|
||||
* @return the value of log(2) with the appropriate precision.
|
||||
*/
|
||||
private NumberInterface getLog2(NumberInterface number) {
|
||||
NumberInterface maxError = number.getMaxError();
|
||||
//NumberInterface errorBound = fromInt(number.getClass(), 1);
|
||||
//We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
|
||||
//In the following, a=1/3^n, b=1/4^n, c = 1/n.
|
||||
//a is also an error bound.
|
||||
NumberInterface a = fromInt(number.getClass(), 1), b = a, c = a;
|
||||
NumberInterface sum = fromInt(number.getClass(), 0);
|
||||
NumberInterface one = fromInt(number.getClass(), 1);
|
||||
int n = 0;
|
||||
while (a.compareTo(maxError) >= 1) {
|
||||
n++;
|
||||
a = a.divide(fromInt(number.getClass(), 3));
|
||||
b = b.divide(fromInt(number.getClass(), 4));
|
||||
c = one.divide(fromInt(number.getClass(), n));
|
||||
sum = sum.add(a.add(b).multiply(c));
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Gets a random number smaller or equal to the given number's integer value.
|
||||
*/
|
||||
public static final Function FUNCTION_RAND_INT = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return fromInt(params[0].getClass(), (int) Math.round(Math.random() * params[0].floor().intValue()));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The caret / pow operator, ^
|
||||
*/
|
||||
public static final Operator OP_CARET = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2, new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
NumberInterface zero = fromInt(params[0].getClass(), 0);
|
||||
return params.length == 2
|
||||
&& !(params[0].compareTo(zero) == 0
|
||||
&& params[1].compareTo(zero) == 0)
|
||||
&& !(params[0].signum() == -1 && params[1].fractionalPart().compareTo(zero) != 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
NumberInterface zero = fromInt(params[0].getClass(), 0);
|
||||
if (params[0].compareTo(zero) == 0)
|
||||
return zero;
|
||||
else if (params[1].compareTo(zero) == 0)
|
||||
return fromInt(params[0].getClass(), 1);
|
||||
//Detect integer bases:
|
||||
if (params[0].fractionalPart().compareTo(fromInt(params[0].getClass(), 0)) == 0
|
||||
&& FUNCTION_ABS.apply(params[1]).compareTo(fromInt(params[0].getClass(), Integer.MAX_VALUE)) < 0
|
||||
&& FUNCTION_ABS.apply(params[1]).compareTo(fromInt(params[1].getClass(), 1)) >= 0) {
|
||||
NumberInterface[] newParams = {params[0], params[1].fractionalPart()};
|
||||
return params[0].intPow(params[1].floor().intValue()).multiply(applyInternal(newParams));
|
||||
}
|
||||
return FUNCTION_EXP.apply(FUNCTION_LN.apply(FUNCTION_ABS.apply(params[0])).multiply(params[1]));
|
||||
}
|
||||
});
|
||||
/**
|
||||
* The square root function.
|
||||
*/
|
||||
public static final Function FUNCTION_SQRT = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return OP_CARET.getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
|
||||
}
|
||||
};
|
||||
private static final HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> FACTORIAL_LISTS = new HashMap<>();
|
||||
/**
|
||||
* The exponential function, exp(1) = e^1 = 2.71...
|
||||
*/
|
||||
public static final Function FUNCTION_EXP = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
NumberInterface maxError = params[0].getMaxError();
|
||||
int n = 0;
|
||||
if (params[0].signum() < 0) {
|
||||
NumberInterface[] negatedParams = {params[0].negate()};
|
||||
return fromInt(params[0].getClass(), 1).divide(applyInternal(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.
|
||||
NumberInterface sum = fromInt(params[0].getClass(), 1);
|
||||
NumberInterface nextNumerator = params[0];
|
||||
NumberInterface left = params[0].multiply(fromInt(params[0].getClass(), 3).intPow(params[0].ceiling().intValue())), right = maxError;
|
||||
do {
|
||||
sum = sum.add(nextNumerator.divide(factorial(params[0].getClass(), n + 1)));
|
||||
n++;
|
||||
nextNumerator = nextNumerator.multiply(params[0]);
|
||||
left = left.multiply(params[0]);
|
||||
NumberInterface nextN = fromInt(params[0].getClass(), n + 1);
|
||||
right = right.multiply(nextN);
|
||||
//System.out.println(left + ", " + right);
|
||||
}
|
||||
while (left.compareTo(right) > 0);
|
||||
//System.out.println(n+1);
|
||||
return sum;
|
||||
}
|
||||
}
|
||||
};
|
||||
/**
|
||||
* 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 = piFor(params[0].getClass());
|
||||
NumberInterface twoPi = pi.multiply(fromInt(pi.getClass(), 2));
|
||||
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(fromInt(pi.getClass(), 2))) > 0) {
|
||||
theta = pi.subtract(theta);
|
||||
}
|
||||
//System.out.println(theta);
|
||||
return sinTaylor(theta);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The cosine function (the argument is in radians).
|
||||
*/
|
||||
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(piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
|
||||
.subtract(params[0]));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The tangent function (the argument is in radians).
|
||||
*/
|
||||
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]));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The secant function (the argument is in radians).
|
||||
*/
|
||||
public final Function functionSec = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return fromInt(params[0].getClass(), 1).divide(functionCos.apply(params[0]));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The cosecant function (the argument is in radians).
|
||||
*/
|
||||
public final Function functionCsc = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return fromInt(params[0].getClass(), 1).divide(functionSin.apply(params[0]));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The cotangent function (the argument is in radians).
|
||||
*/
|
||||
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(functionSin.apply(params[0]));
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arcsine function (return type in radians).
|
||||
*/
|
||||
public final Function functionArcsin = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1
|
||||
&& FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 1)) <= 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
if (FUNCTION_ABS.apply(params[0]).compareTo(new NaiveNumber(0.8).promoteTo(params[0].getClass())) >= 0) {
|
||||
NumberInterface[] newParams = {FUNCTION_SQRT.apply(fromInt(params[0].getClass(), 1).subtract(params[0].multiply(params[0])))};
|
||||
return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
|
||||
.subtract(applyInternal(newParams)).multiply(fromInt(params[0].getClass(), params[0].signum()));
|
||||
}
|
||||
NumberInterface currentTerm = params[0], sum = currentTerm,
|
||||
multiplier = currentTerm.multiply(currentTerm), summandBound = sum.getMaxError().multiply(fromInt(sum.getClass(), 1).subtract(multiplier)),
|
||||
power = currentTerm, coefficient = fromInt(params[0].getClass(), 1);
|
||||
int exponent = 1;
|
||||
while (FUNCTION_ABS.apply(currentTerm).compareTo(summandBound) > 0) {
|
||||
exponent += 2;
|
||||
power = power.multiply(multiplier);
|
||||
coefficient = coefficient.multiply(fromInt(params[0].getClass(), exponent - 2))
|
||||
.divide(fromInt(params[0].getClass(), exponent - 1));
|
||||
currentTerm = power.multiply(coefficient).divide(fromInt(power.getClass(), exponent));
|
||||
sum = sum.add(currentTerm);
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arccosine function.
|
||||
*/
|
||||
public final Function functionArccos = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1 && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 1)) <= 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
|
||||
.subtract(functionArcsin.apply(params));
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arccosecant function.
|
||||
*/
|
||||
public final Function functionArccsc = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1 && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 1)) >= 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
NumberInterface[] reciprocalParamArr = {fromInt(params[0].getClass(), 1).divide(params[0])};
|
||||
return functionArcsin.apply(reciprocalParamArr);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arcsecant function.
|
||||
*/
|
||||
public final Function functionArcsec = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1 && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 1)) >= 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
NumberInterface[] reciprocalParamArr = {fromInt(params[0].getClass(), 1).divide(params[0])};
|
||||
return functionArccos.apply(reciprocalParamArr);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arctangent function.
|
||||
*/
|
||||
public final Function functionArctan = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
if (params[0].signum() == -1) {
|
||||
NumberInterface[] negatedParams = {params[0].negate()};
|
||||
return applyInternal(negatedParams).negate();
|
||||
}
|
||||
if (params[0].compareTo(fromInt(params[0].getClass(), 1)) > 0) {
|
||||
NumberInterface[] reciprocalParams = {fromInt(params[0].getClass(), 1).divide(params[0])};
|
||||
return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
|
||||
.subtract(applyInternal(reciprocalParams));
|
||||
}
|
||||
if (params[0].compareTo(fromInt(params[0].getClass(), 1)) == 0) {
|
||||
return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 4));
|
||||
}
|
||||
if (params[0].compareTo(new NaiveNumber(0.9).promoteTo(params[0].getClass())) >= 0) {
|
||||
NumberInterface[] newParams = {params[0].multiply(fromInt(params[0].getClass(), 2))
|
||||
.divide(fromInt(params[0].getClass(), 1).subtract(params[0].multiply(params[0])))};
|
||||
return applyInternal(newParams).divide(fromInt(params[0].getClass(), 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(currentTerm).compareTo(maxError) > 0) {
|
||||
n += 2;
|
||||
currentPower = currentPower.multiply(multiplier);
|
||||
currentTerm = currentPower.divide(fromInt(currentPower.getClass(), n));
|
||||
sum = sum.add(currentTerm);
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arccotangent function. Range: (0, pi).
|
||||
*/
|
||||
public final Function functionArccot = new Function() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
|
||||
.subtract(functionArctan.apply(params));
|
||||
}
|
||||
};
|
||||
|
||||
public StandardPlugin(PluginManager manager) {
|
||||
super(manager);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a partial sum of a series whose terms are given by the nthTermFunction, evaluated at x.
|
||||
*
|
||||
* @param x the value at which the series is evaluated.
|
||||
* @param nthTermFunction the function that returns the nth term of the series, in the format term(x, n).
|
||||
* @param n the number of terms in the partial sum.
|
||||
* @return the value of the partial sum that has the same class as x.
|
||||
*/
|
||||
private static NumberInterface sumSeries(NumberInterface x, BiFunction<Integer, NumberInterface, NumberInterface> nthTermFunction, int n) {
|
||||
NumberInterface sum = fromInt(x.getClass(), 0);
|
||||
for (int i = 0; i <= n; i++) {
|
||||
sum = sum.add(nthTermFunction.apply(i, x));
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
if (!FACTORIAL_LISTS.containsKey(numberClass)) {
|
||||
FACTORIAL_LISTS.put(numberClass, new ArrayList<>());
|
||||
FACTORIAL_LISTS.get(numberClass).add(fromInt(numberClass, 1));
|
||||
FACTORIAL_LISTS.get(numberClass).add(fromInt(numberClass, 1));
|
||||
}
|
||||
ArrayList<NumberInterface> list = FACTORIAL_LISTS.get(numberClass);
|
||||
if (n >= list.size()) {
|
||||
while (list.size() < n + 16) {
|
||||
list.add(list.get(list.size() - 1).multiply(fromInt(numberClass, list.size())));
|
||||
}
|
||||
}
|
||||
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 = x.getMaxError();
|
||||
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(fromInt(pi.getClass(), 2));
|
||||
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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a number of class numType with value n.
|
||||
*
|
||||
* @param numType class of number to return.
|
||||
* @param n value of returned number.
|
||||
* @return numClass instance with value n.
|
||||
*/
|
||||
private static NumberInterface fromInt(Class<? extends NumberInterface> numType, int n) {
|
||||
if (!integerValues.containsKey(numType)) {
|
||||
integerValues.put(numType, new HashMap<>());
|
||||
}
|
||||
if (!integerValues.get(numType).containsKey(n)) {
|
||||
integerValues.get(numType).put(n, new NaiveNumber(n).promoteTo(numType));
|
||||
}
|
||||
return integerValues.get(numType).get(n);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onEnable() {
|
||||
registerNumberImplementation("naive", IMPLEMENTATION_NAIVE);
|
||||
registerNumberImplementation("precise", IMPLEMENTATION_PRECISE);
|
||||
|
||||
registerOperator("+", OP_ADD);
|
||||
registerOperator("-", OP_SUBTRACT);
|
||||
registerOperator("`", OP_NEGATE);
|
||||
registerOperator("*", OP_MULTIPLY);
|
||||
registerOperator("/", OP_DIVIDE);
|
||||
registerOperator("^", OP_CARET);
|
||||
registerOperator("!", OP_FACTORIAL);
|
||||
|
||||
registerOperator("nPr", OP_NPR);
|
||||
registerOperator("nCr", OP_NCR);
|
||||
|
||||
registerFunction("abs", FUNCTION_ABS);
|
||||
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);
|
||||
|
||||
registerFunction("arcsin", functionArcsin);
|
||||
registerFunction("arccos", functionArccos);
|
||||
registerFunction("arctan", functionArctan);
|
||||
registerFunction("arcsec", functionArcsec);
|
||||
registerFunction("arccsc", functionArccsc);
|
||||
registerFunction("arccot", functionArccot);
|
||||
|
||||
registerFunction("random_int", FUNCTION_RAND_INT);
|
||||
|
||||
registerDocumentation(new Documentation("abs", "Absolute Value", "Finds the distance " +
|
||||
"from zero of a number.", "Given a number, this function finds the distance form " +
|
||||
"zero of a number, effectively turning negative numbers into positive ones.\n\n" +
|
||||
"Example: abs(-2) -> 2", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("exp", "Exponentiate", "Brings e to the given power.",
|
||||
"This function evaluates e to the power of the given value, and is the inverse " +
|
||||
"of the natural logarithm.\n\n" +
|
||||
"Example: exp(1) -> 2.718...", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("ln", "Natural Logarithm", "Gets the natural " +
|
||||
"logarithm of the given value.", "The natural logarithm of a number is " +
|
||||
"the power that e has to be brought to to be equal to the number.\n\n" +
|
||||
"Example: ln(2.718) -> 1", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("sqrt", "Square Root", "Finds the square root " +
|
||||
"of the number.", "A square root a of a number is defined as the non-negative a such that a times a is equal " +
|
||||
"to that number.\n\n" +
|
||||
"Example: sqrt(4) -> 2", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("sin", "Sine", "Computes the sine of the given angle, " +
|
||||
"in radians.", "Example: sin(pi/6) -> 0.5", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("cos", "Cosine", "Computes the cosine of the given angle, " +
|
||||
"in radians.", "Example: cos(pi/6) -> 0.866... (the exact result is sqrt(3)/2)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("tan", "Tangent", "Computes the tangent of the given angle, " +
|
||||
"in radians.", "Example: tan(pi/6) -> 0.577... (the exact result is 1/sqrt(3))", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("sec", "Secant", "Computes the secant of the given angle, " +
|
||||
"in radians.", "Example: sec(pi/6) -> 1.154... (the exact result is 2/sqrt(3))", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("csc", "Cosecant", "Computes the cosecant of the given angle, " +
|
||||
"in radians.", "Example: csc(pi/6) -> 2", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("cot", "Cotangent", "Computes the cotangent of the given angle, " +
|
||||
"in radians.", "Example: cot(pi/6) -> 1.732... (the exact result is sqrt(3))", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("random_int", "Random Integer", "Generates a random integer [0, n].",
|
||||
"Generates a pseudorandom number using the standard JVM random mechanism, keeping it less than or " +
|
||||
"equal to the given number.\n\n" +
|
||||
"Example: random_int(5) -> 4\n" +
|
||||
"random_int(5) -> 3\n" +
|
||||
"random_int(5) -> 3\n", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arcsin", "Arcsine", "Computes the arcsine of x. (The result is in radians.)",
|
||||
"Example: arcsin(0.5) -> 0.523... (the exact result is pi/6)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arccos", "Arccosine", "Computes the arccosine of x. (The result is in radians.)",
|
||||
"Example: arccos(0.5) -> 1.047... (the exact result is pi/3)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arctan", "Arctangent", "Computes the arctangent of x. (The result is in radians.)",
|
||||
"Example: arctan(1) -> 0.785... (the exact result is pi/4)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arcsec", "Arcsecant", "Computes the arcsecant of x. (The result is in radians.)",
|
||||
"Example: arcsec(2) -> 1.047... (the exact result is pi/3)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arccsc", "Arccosecant", "Computes the arcscosecant of x. (The result is in radians.)",
|
||||
"Example: arccsc(2) -> 0.523... (the exact result is pi/6)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arccot", "Arccotangent", "Computes the arccotangent of x. (The result is in radians," +
|
||||
" in the range (0, pi).)",
|
||||
"Example: arccot(0) -> 1.570... (the exact result is pi/2)", DocumentationType.FUNCTION));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onDisable() {
|
||||
|
||||
}
|
||||
}
|
|
@ -0,0 +1,679 @@
|
|||
package org.nwapw.abacus.plugin.standard;
|
||||
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.nwapw.abacus.context.MutableEvaluationContext;
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext;
|
||||
import org.nwapw.abacus.function.Documentation;
|
||||
import org.nwapw.abacus.function.DocumentationType;
|
||||
import org.nwapw.abacus.function.interfaces.NumberFunction;
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator;
|
||||
import org.nwapw.abacus.function.interfaces.TreeValueOperator;
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
import org.nwapw.abacus.number.standard.NaiveNumber;
|
||||
import org.nwapw.abacus.number.standard.PreciseNumber;
|
||||
import org.nwapw.abacus.plugin.NumberImplementation;
|
||||
import org.nwapw.abacus.plugin.Plugin;
|
||||
import org.nwapw.abacus.plugin.PluginManager;
|
||||
import org.nwapw.abacus.plugin.standard.operator.*;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
|
||||
/**
|
||||
* The plugin providing standard functions such as addition and subtraction to
|
||||
* the calculator.
|
||||
*/
|
||||
public class StandardPlugin extends Plugin {
|
||||
|
||||
/**
|
||||
* The set operator.
|
||||
*/
|
||||
public static final TreeValueOperator OP_SET = new OperatorSet();
|
||||
/**
|
||||
* The define operator.
|
||||
*/
|
||||
public final TreeValueOperator OP_DEFINE = new OperatorDefine();
|
||||
/**
|
||||
* The addition operator, +
|
||||
*/
|
||||
public static final NumberOperator OP_ADD = new OperatorAdd();
|
||||
/**
|
||||
* The subtraction operator, -
|
||||
*/
|
||||
public static final NumberOperator OP_SUBTRACT = new OperatorSubtract();
|
||||
/**
|
||||
* The negation operator, -
|
||||
*/
|
||||
public static final NumberOperator OP_NEGATE = new OperatorNegate();
|
||||
/**
|
||||
* The multiplication operator, *
|
||||
*/
|
||||
public static final NumberOperator OP_MULTIPLY = new OperatorMultiply();
|
||||
/**
|
||||
* 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() {
|
||||
MutableEvaluationContext dummyContext = new MutableEvaluationContext(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;
|
||||
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 PreciseNumber((12 * i + 2) + ""))
|
||||
.multiply(new PreciseNumber((12 * i + 6) + ""))
|
||||
.multiply(new PreciseNumber((12 * i + 10) + ""))
|
||||
.divide(new PreciseNumber(Math.pow(i + 1, 3) + ""));
|
||||
L = L.add(lSummand);
|
||||
X = X.multiply(xMultiplier);
|
||||
sum = sum.add(M.multiply(L).divide(X));
|
||||
}
|
||||
return C.divide(sum);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The division operator, /
|
||||
*/
|
||||
public static final NumberOperator OP_DIVIDE = new OperatorDivide();
|
||||
/**
|
||||
* The factorial operator, !
|
||||
*/
|
||||
public static final NumberOperator OP_FACTORIAL = new OperatorFactorial();
|
||||
/**
|
||||
* The permutation operator.
|
||||
*/
|
||||
public static final NumberOperator OP_NPR = new OperatorNpr();
|
||||
/**
|
||||
* The combination operator.
|
||||
*/
|
||||
public static final NumberOperator OP_NCR = new OperatorNcr();
|
||||
/**
|
||||
* The absolute value function, abs(-3) = 3
|
||||
*/
|
||||
public static final NumberFunction FUNCTION_ABS = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params[0].multiply(context.getInheritedNumberImplementation().instanceForString(Integer.toString(params[0].signum())));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The natural log function.
|
||||
*/
|
||||
public static final NumberFunction FUNCTION_LN = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1 && params[0].compareTo(context.getInheritedNumberImplementation().instanceForString("0")) > 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
NumberImplementation implementation = context.getInheritedNumberImplementation();
|
||||
NumberInterface param = params[0];
|
||||
NumberInterface one = implementation.instanceForString("1");
|
||||
int powersOf2 = 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++;
|
||||
if (param.subtract(one).signum() != 1) {
|
||||
break;
|
||||
//No infinite loop for you.
|
||||
}
|
||||
} else {
|
||||
param = param.multiply(implementation.instanceForString("2"));
|
||||
powersOf2--;
|
||||
if (param.subtract(one).signum() != -1) {
|
||||
break;
|
||||
//No infinite loop for you.
|
||||
}
|
||||
}
|
||||
}
|
||||
return getLog2(context.getInheritedNumberImplementation(), param).multiply(implementation.instanceForString(Integer.toString(powersOf2))).add(getLogPartialSum(context, param));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the partial sum of the Taylor series for logx (around x=1).
|
||||
* Automatically determines the number of terms needed based on the precision of x.
|
||||
*
|
||||
* @param context
|
||||
* @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(PluginEvaluationContext 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(context, currentTerm).compareTo(maxError) > 0) {
|
||||
n++;
|
||||
currentNumerator = currentNumerator.multiply(x).negate();
|
||||
currentTerm = currentNumerator.divide(implementation.instanceForString(Integer.toString(n)));
|
||||
sum = sum.add(currentTerm);
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns natural log of 2 to the required precision of the class of number.
|
||||
* @param number a number of the same type as the return type. (Used for precision.)
|
||||
* @return the value of log(2) with the appropriate precision.
|
||||
*/
|
||||
private NumberInterface getLog2(NumberImplementation implementation, NumberInterface number) {
|
||||
NumberInterface maxError = number.getMaxError();
|
||||
//NumberInterface errorBound = implementation.instanceForString("1");
|
||||
//We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
|
||||
//In the following, a=1/3^n, b=1/4^n, c = 1/n.
|
||||
//a is also an error bound.
|
||||
NumberInterface a = implementation.instanceForString("1"), b = a, c;
|
||||
NumberInterface sum = implementation.instanceForString("0");
|
||||
NumberInterface one = implementation.instanceForString("1");
|
||||
int n = 0;
|
||||
while (a.compareTo(maxError) >= 1) {
|
||||
n++;
|
||||
a = a.divide(implementation.instanceForString("3"));
|
||||
b = b.divide(implementation.instanceForString("4"));
|
||||
c = one.divide(implementation.instanceForString(Integer.toString(n)));
|
||||
sum = sum.add(a.add(b).multiply(c));
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Gets a random number smaller or equal to the given number's integer value.
|
||||
*/
|
||||
public static final NumberFunction FUNCTION_RAND_INT = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return context.getInheritedNumberImplementation().instanceForString(Long.toString(Math.round(Math.random() * params[0].floor().intValue())));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The caret / pow operator, ^
|
||||
*/
|
||||
public static final NumberOperator OP_CARET = new OperatorCaret();
|
||||
/**
|
||||
* The square root function.
|
||||
*/
|
||||
public static final NumberFunction FUNCTION_SQRT = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return OP_CARET.apply(context, params[0], context.getInheritedNumberImplementation().instanceForString(".5"));
|
||||
}
|
||||
};
|
||||
private static final HashMap<NumberImplementation, ArrayList<NumberInterface>> FACTORIAL_LISTS = new HashMap<>();
|
||||
/**
|
||||
* The exponential function, exp(1) = e^1 = 2.71...
|
||||
*/
|
||||
public static final NumberFunction FUNCTION_EXP = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext 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(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.
|
||||
NumberInterface sum = implementation.instanceForString("1");
|
||||
NumberInterface nextNumerator = params[0];
|
||||
NumberInterface left = params[0].multiply(implementation.instanceForString("3").intPow(params[0].ceiling().intValue())), right = maxError;
|
||||
do {
|
||||
sum = sum.add(nextNumerator.divide(factorial(implementation, n + 1)));
|
||||
n++;
|
||||
nextNumerator = nextNumerator.multiply(params[0]);
|
||||
left = left.multiply(params[0]);
|
||||
NumberInterface nextN = implementation.instanceForString(Integer.toString(n + 1));
|
||||
right = right.multiply(nextN);
|
||||
//System.out.println(left + ", " + right);
|
||||
}
|
||||
while (left.compareTo(right) > 0);
|
||||
//System.out.println(n+1);
|
||||
return sum;
|
||||
}
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The sine function (the argument is interpreted in radians).
|
||||
*/
|
||||
public final NumberFunction functionSin = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
NumberImplementation implementation = context.getInheritedNumberImplementation();
|
||||
NumberInterface pi = piFor(params[0].getClass());
|
||||
NumberInterface twoPi = pi.multiply(implementation.instanceForString("2"));
|
||||
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);
|
||||
} else if (theta.compareTo(pi.divide(implementation.instanceForString("2"))) > 0) {
|
||||
theta = pi.subtract(theta);
|
||||
}
|
||||
//System.out.println(theta);
|
||||
return sinTaylor(context, theta);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The cosine function (the argument is in radians).
|
||||
*/
|
||||
public final NumberFunction functionCos = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return functionSin.apply(context, piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2"))
|
||||
.subtract(params[0]));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The tangent function (the argument is in radians).
|
||||
*/
|
||||
public final NumberFunction functionTan = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return functionSin.apply(context, params[0]).divide(functionCos.apply(context, params[0]));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The secant function (the argument is in radians).
|
||||
*/
|
||||
public final NumberFunction functionSec = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return context.getInheritedNumberImplementation().instanceForString("1").divide(functionCos.apply(context, params[0]));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The cosecant function (the argument is in radians).
|
||||
*/
|
||||
public final NumberFunction functionCsc = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return context.getInheritedNumberImplementation().instanceForString("1").divide(functionSin.apply(context, params[0]));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The cotangent function (the argument is in radians).
|
||||
*/
|
||||
public final NumberFunction functionCot = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return functionCos.apply(context, params[0]).divide(functionSin.apply(context, params[0]));
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arcsine function (return type in radians).
|
||||
*/
|
||||
public final NumberFunction functionArcsin = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1
|
||||
&& FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) <= 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext 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(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(context, currentTerm).compareTo(summandBound) > 0) {
|
||||
exponent += 2;
|
||||
power = power.multiply(multiplier);
|
||||
coefficient = coefficient.multiply(implementation.instanceForString(Integer.toString(exponent - 2)))
|
||||
.divide(implementation.instanceForString(Integer.toString(exponent - 1)));
|
||||
currentTerm = power.multiply(coefficient).divide(implementation.instanceForString(Integer.toString(exponent)));
|
||||
sum = sum.add(currentTerm);
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arccosine function.
|
||||
*/
|
||||
public final NumberFunction functionArccos = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1 && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) <= 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2"))
|
||||
.subtract(functionArcsin.apply(context, params));
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arccosecant function.
|
||||
*/
|
||||
public final NumberFunction functionArccsc = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1 && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) >= 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
NumberInterface[] reciprocalParamArr = {context.getInheritedNumberImplementation().instanceForString("1").divide(params[0])};
|
||||
return functionArcsin.apply(context, reciprocalParamArr);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arcsecant function.
|
||||
*/
|
||||
public final NumberFunction functionArcsec = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1 && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) >= 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
NumberInterface[] reciprocalParamArr = {context.getInheritedNumberImplementation().instanceForString("1").divide(params[0])};
|
||||
return functionArccos.apply(context, reciprocalParamArr);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arctangent function.
|
||||
*/
|
||||
public final NumberFunction functionArctan = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
NumberImplementation implementation = context.getInheritedNumberImplementation();
|
||||
if (params[0].signum() == -1) {
|
||||
NumberInterface[] negatedParams = {params[0].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(context, reciprocalParams));
|
||||
}
|
||||
if (params[0].compareTo(implementation.instanceForString("1")) == 0) {
|
||||
return piFor(params[0].getClass()).divide(implementation.instanceForString("4"));
|
||||
}
|
||||
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(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(context, currentTerm).compareTo(maxError) > 0) {
|
||||
n += 2;
|
||||
currentPower = currentPower.multiply(multiplier);
|
||||
currentTerm = currentPower.divide(implementation.instanceForString(Integer.toString(n)));
|
||||
sum = sum.add(currentTerm);
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The arccotangent function. Range: (0, pi).
|
||||
*/
|
||||
public final NumberFunction functionArccot = new NumberFunction() {
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2"))
|
||||
.subtract(functionArctan.apply(context, params));
|
||||
}
|
||||
};
|
||||
|
||||
public StandardPlugin(PluginManager manager) {
|
||||
super(manager);
|
||||
}
|
||||
|
||||
/**
|
||||
* A factorial function that uses memoization for each number class; it efficiently
|
||||
* computes factorials of non-negative integers.
|
||||
*
|
||||
* @param implementation type of number to return.
|
||||
* @param n non-negative integer.
|
||||
* @return a number of numClass with value n factorial.
|
||||
*/
|
||||
synchronized public static NumberInterface factorial(NumberImplementation implementation, int n) {
|
||||
if (!FACTORIAL_LISTS.containsKey(implementation)) {
|
||||
FACTORIAL_LISTS.put(implementation, new ArrayList<>());
|
||||
FACTORIAL_LISTS.get(implementation).add(implementation.instanceForString("1"));
|
||||
FACTORIAL_LISTS.get(implementation).add(implementation.instanceForString("1"));
|
||||
}
|
||||
ArrayList<NumberInterface> list = FACTORIAL_LISTS.get(implementation);
|
||||
if (n >= list.size()) {
|
||||
while (list.size() < n + 16) {
|
||||
list.add(list.get(list.size() - 1).multiply(implementation.instanceForString(Integer.toString(list.size()))));
|
||||
}
|
||||
}
|
||||
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(PluginEvaluationContext context, NumberInterface x) {
|
||||
NumberInterface power = x, multiplier = x.multiply(x).negate(), currentTerm, sum = x;
|
||||
NumberInterface maxError = x.getMaxError();
|
||||
int n = 1;
|
||||
do {
|
||||
n += 2;
|
||||
power = power.multiply(multiplier);
|
||||
currentTerm = power.divide(factorial(context.getInheritedNumberImplementation(), n));
|
||||
sum = sum.add(currentTerm);
|
||||
} while (FUNCTION_ABS.apply(context, 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(PluginEvaluationContext 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);
|
||||
}
|
||||
return theta;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onEnable() {
|
||||
registerNumberImplementation("naive", IMPLEMENTATION_NAIVE);
|
||||
registerNumberImplementation("precise", IMPLEMENTATION_PRECISE);
|
||||
|
||||
registerOperator("+", OP_ADD);
|
||||
registerOperator("-", OP_SUBTRACT);
|
||||
registerOperator("`", OP_NEGATE);
|
||||
registerOperator("*", OP_MULTIPLY);
|
||||
registerOperator("/", OP_DIVIDE);
|
||||
registerOperator("^", OP_CARET);
|
||||
registerOperator("!", OP_FACTORIAL);
|
||||
|
||||
registerTreeValueOperator("=", OP_SET);
|
||||
registerTreeValueOperator(":=", OP_DEFINE);
|
||||
|
||||
registerOperator("nPr", OP_NPR);
|
||||
registerOperator("nCr", OP_NCR);
|
||||
|
||||
registerFunction("abs", FUNCTION_ABS);
|
||||
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);
|
||||
|
||||
registerFunction("arcsin", functionArcsin);
|
||||
registerFunction("arccos", functionArccos);
|
||||
registerFunction("arctan", functionArctan);
|
||||
registerFunction("arcsec", functionArcsec);
|
||||
registerFunction("arccsc", functionArccsc);
|
||||
registerFunction("arccot", functionArccot);
|
||||
|
||||
registerFunction("random_int", FUNCTION_RAND_INT);
|
||||
|
||||
registerDocumentation(new Documentation("abs", "Absolute Value", "Finds the distance " +
|
||||
"from zero of a number.", "Given a number, this function finds the distance form " +
|
||||
"zero of a number, effectively turning negative numbers into positive ones.\n\n" +
|
||||
"Example: abs(-2) -> 2", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("exp", "Exponentiate", "Brings e to the given power.",
|
||||
"This function evaluates e to the power of the given value, and is the inverse " +
|
||||
"of the natural logarithm.\n\n" +
|
||||
"Example: exp(1) -> 2.718...", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("ln", "Natural Logarithm", "Gets the natural " +
|
||||
"logarithm of the given value.", "The natural logarithm of a number is " +
|
||||
"the power that e has to be brought to to be equal to the number.\n\n" +
|
||||
"Example: ln(2.718) -> 1", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("sqrt", "Square Root", "Finds the square root " +
|
||||
"of the number.", "A square root a of a number is defined as the non-negative a such that a times a is equal " +
|
||||
"to that number.\n\n" +
|
||||
"Example: sqrt(4) -> 2", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("sin", "Sine", "Computes the sine of the given angle, " +
|
||||
"in radians.", "Example: sin(pi/6) -> 0.5", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("cos", "Cosine", "Computes the cosine of the given angle, " +
|
||||
"in radians.", "Example: cos(pi/6) -> 0.866... (the exact result is sqrt(3)/2)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("tan", "Tangent", "Computes the tangent of the given angle, " +
|
||||
"in radians.", "Example: tan(pi/6) -> 0.577... (the exact result is 1/sqrt(3))", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("sec", "Secant", "Computes the secant of the given angle, " +
|
||||
"in radians.", "Example: sec(pi/6) -> 1.154... (the exact result is 2/sqrt(3))", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("csc", "Cosecant", "Computes the cosecant of the given angle, " +
|
||||
"in radians.", "Example: csc(pi/6) -> 2", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("cot", "Cotangent", "Computes the cotangent of the given angle, " +
|
||||
"in radians.", "Example: cot(pi/6) -> 1.732... (the exact result is sqrt(3))", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("random_int", "Random Integer", "Generates a random integer [0, n].",
|
||||
"Generates a pseudorandom number using the standard JVM random mechanism, keeping it less than or " +
|
||||
"equal to the given number.\n\n" +
|
||||
"Example: random_int(5) -> 4\n" +
|
||||
"random_int(5) -> 3\n" +
|
||||
"random_int(5) -> 3\n", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arcsin", "Arcsine", "Computes the arcsine of x. (The result is in radians.)",
|
||||
"Example: arcsin(0.5) -> 0.523... (the exact result is pi/6)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arccos", "Arccosine", "Computes the arccosine of x. (The result is in radians.)",
|
||||
"Example: arccos(0.5) -> 1.047... (the exact result is pi/3)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arctan", "Arctangent", "Computes the arctangent of x. (The result is in radians.)",
|
||||
"Example: arctan(1) -> 0.785... (the exact result is pi/4)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arcsec", "Arcsecant", "Computes the arcsecant of x. (The result is in radians.)",
|
||||
"Example: arcsec(2) -> 1.047... (the exact result is pi/3)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arccsc", "Arccosecant", "Computes the arcscosecant of x. (The result is in radians.)",
|
||||
"Example: arccsc(2) -> 0.523... (the exact result is pi/6)", DocumentationType.FUNCTION));
|
||||
registerDocumentation(new Documentation("arccot", "Arccotangent", "Computes the arccotangent of x. (The result is in radians," +
|
||||
" in the range (0, pi).)",
|
||||
"Example: arccot(0) -> 1.570... (the exact result is pi/2)", DocumentationType.FUNCTION));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onDisable() {
|
||||
FACTORIAL_LISTS.clear();
|
||||
}
|
||||
}
|
|
@ -1,54 +0,0 @@
|
|||
package org.nwapw.abacus.tree;
|
||||
|
||||
import org.nwapw.abacus.Abacus;
|
||||
import org.nwapw.abacus.function.Function;
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
|
||||
/**
|
||||
* A reducer implementation that turns a tree into a single number.
|
||||
* This is not always guaranteed to work.
|
||||
*/
|
||||
public class NumberReducer implements Reducer<NumberInterface> {
|
||||
|
||||
/**
|
||||
* The plugin manager from which to draw the functions.
|
||||
*/
|
||||
private Abacus abacus;
|
||||
|
||||
/**
|
||||
* Creates a new number reducer.
|
||||
*
|
||||
* @param abacus the calculator instance.
|
||||
*/
|
||||
public NumberReducer(Abacus abacus) {
|
||||
this.abacus = abacus;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface reduceNode(TreeNode node, Object... children) {
|
||||
if (node instanceof NumberNode) {
|
||||
return ((NumberNode) node).getNumber();
|
||||
} else if (node instanceof BinaryNode) {
|
||||
NumberInterface left = (NumberInterface) children[0];
|
||||
NumberInterface right = (NumberInterface) children[1];
|
||||
Function function = abacus.getPluginManager().operatorFor(((BinaryNode) node).getOperation()).getFunction();
|
||||
if (function == null) return null;
|
||||
return function.apply(left, right);
|
||||
} else if (node instanceof UnaryNode) {
|
||||
NumberInterface child = (NumberInterface) children[0];
|
||||
Function functionn = abacus.getPluginManager().operatorFor(((UnaryNode) node).getOperation()).getFunction();
|
||||
if (functionn == null) return null;
|
||||
return functionn.apply(child);
|
||||
} else if (node instanceof FunctionNode) {
|
||||
NumberInterface[] convertedChildren = new NumberInterface[children.length];
|
||||
for (int i = 0; i < convertedChildren.length; i++) {
|
||||
convertedChildren[i] = (NumberInterface) children[i];
|
||||
}
|
||||
Function function = abacus.getPluginManager().functionFor(((FunctionNode) node).getFunction());
|
||||
if (function == null) return null;
|
||||
return function.apply(convertedChildren);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,112 @@
|
|||
package org.nwapw.abacus
|
||||
|
||||
import org.nwapw.abacus.config.Configuration
|
||||
import org.nwapw.abacus.context.EvaluationContext
|
||||
import org.nwapw.abacus.context.MutableEvaluationContext
|
||||
import org.nwapw.abacus.number.promotion.PromotionManager
|
||||
import org.nwapw.abacus.parsing.TreeBuilder
|
||||
import org.nwapw.abacus.parsing.standard.LexerTokenizer
|
||||
import org.nwapw.abacus.parsing.standard.ShuntingYardParser
|
||||
import org.nwapw.abacus.plugin.PluginManager
|
||||
import org.nwapw.abacus.plugin.standard.StandardPlugin
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
|
||||
/**
|
||||
* Core class to handle all mathematics.
|
||||
*
|
||||
* The main calculator class. This is responsible
|
||||
* for piecing together all of the components, allowing
|
||||
* their interaction with each other.
|
||||
*
|
||||
* @property configuration the configuration to use.
|
||||
*/
|
||||
class Abacus(val configuration: Configuration) {
|
||||
|
||||
/**
|
||||
* The tokenizer used to convert strings into tokens.
|
||||
*/
|
||||
private val tokenizer = LexerTokenizer()
|
||||
/**
|
||||
* Parser the parser used to convert tokens into trees.
|
||||
*/
|
||||
private val parser = ShuntingYardParser()
|
||||
/**
|
||||
* The plugin manager used to handle loading and unloading plugins.
|
||||
*/
|
||||
val pluginManager = PluginManager(this)
|
||||
/**
|
||||
* The tree builder that handles the conversion of strings into trees.
|
||||
*/
|
||||
val treeBuilder = TreeBuilder(tokenizer, parser)
|
||||
/**
|
||||
* The promotion manager used to convert between number implementations.
|
||||
*/
|
||||
val promotionManager = PromotionManager(this)
|
||||
|
||||
/**
|
||||
* The hidden, mutable implementation of the context.
|
||||
*/
|
||||
private val mutableContext = MutableEvaluationContext(numberImplementation = StandardPlugin.IMPLEMENTATION_NAIVE, abacus = this)
|
||||
/**
|
||||
* The base context from which calculations are started.
|
||||
*/
|
||||
val context: EvaluationContext
|
||||
get() = mutableContext
|
||||
|
||||
init {
|
||||
pluginManager.addListener(tokenizer)
|
||||
pluginManager.addListener(parser)
|
||||
pluginManager.addListener(promotionManager)
|
||||
}
|
||||
|
||||
/**
|
||||
* Reloads the Abacus core.
|
||||
*/
|
||||
fun reload(){
|
||||
with(mutableContext){
|
||||
clearVariables()
|
||||
clearDefinitions()
|
||||
}
|
||||
pluginManager.reload()
|
||||
mutableContext.numberImplementation = pluginManager.numberImplementationFor(configuration.numberImplementation)
|
||||
?: StandardPlugin.IMPLEMENTATION_NAIVE
|
||||
}
|
||||
/**
|
||||
* Merges the current context with the provided one, updating
|
||||
* variables and the like.
|
||||
* @param context the context to apply.
|
||||
*/
|
||||
fun applyToContext(context: EvaluationContext){
|
||||
mutableContext.apply(context)
|
||||
}
|
||||
/**
|
||||
* Parses a string into a tree structure using the main
|
||||
* tree builder.
|
||||
*
|
||||
* @param input the input string to parse
|
||||
* @return the resulting tree, null if the tree builder or the produced tree are null.
|
||||
*/
|
||||
fun parseString(input: String): TreeNode = treeBuilder.fromString(input)
|
||||
/**
|
||||
* Evaluates the given tree.
|
||||
*
|
||||
* @param tree the tree to reduce, must not be null.
|
||||
* @return the evaluation result.
|
||||
*/
|
||||
fun evaluateTree(tree: TreeNode): EvaluationResult {
|
||||
return evaluateTreeWithContext(tree, context.mutableSubInstance())
|
||||
}
|
||||
/**
|
||||
* Evaluates the given tree using a different context than
|
||||
* the default one.
|
||||
*
|
||||
* @param tree the tree to reduce, must not be null.
|
||||
* @param context the context to use for the evaluation.
|
||||
* @return the evaluation result.
|
||||
*/
|
||||
fun evaluateTreeWithContext(tree: TreeNode, context: MutableEvaluationContext): EvaluationResult {
|
||||
val evaluationValue = tree.reduce(context)
|
||||
return EvaluationResult(evaluationValue, context)
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,6 @@
|
|||
package org.nwapw.abacus
|
||||
|
||||
import org.nwapw.abacus.context.MutableEvaluationContext
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
data class EvaluationResult(val value: NumberInterface, val resultingContext: MutableEvaluationContext)
|
|
@ -0,0 +1,20 @@
|
|||
package org.nwapw.abacus.config
|
||||
|
||||
/**
|
||||
* A class that holds information that tells Abacus how to behave.
|
||||
*
|
||||
* Configuration stores information about how Abacus should behave, for
|
||||
* instance, what number implementation it should use and what
|
||||
* plugins should be ignored during loading.
|
||||
*
|
||||
* @property numberImplementation the number implementation Abacus should use for loading.
|
||||
* @param disabledPlugins the plugins that should be disabled and not loaded by the plugin manager.
|
||||
*/
|
||||
open class Configuration(var numberImplementation: String = "<default>", disabledPlugins: Array<String> = emptyArray()) {
|
||||
|
||||
/**
|
||||
* The set of disabled plugins that should be ignored by the plugin manager.
|
||||
*/
|
||||
val disabledPlugins = disabledPlugins.toMutableSet()
|
||||
|
||||
}
|
|
@ -0,0 +1,26 @@
|
|||
package org.nwapw.abacus.context
|
||||
|
||||
import kotlin.reflect.KProperty
|
||||
|
||||
/**
|
||||
* A delegate to accumulate a collection of elements in a [EvaluationContext] hierarchy.
|
||||
*
|
||||
* ChainAccumulateDelegate is similar to the [ChainSearchDelegate], however, it operates only on collections.
|
||||
* Instead of returning the most recent collection, it merges them into a [Set].
|
||||
*
|
||||
* @param T the type of element in the collection.
|
||||
* @property valueGetter the getter used to access the collection from the context.
|
||||
*/
|
||||
class ChainAccumulateDelegate<out T>(private val valueGetter: EvaluationContext.() -> Collection<T>) {
|
||||
|
||||
operator fun getValue(selfRef: Any, property: KProperty<*>): Set<T> {
|
||||
val set = mutableSetOf<T>()
|
||||
var currentRef: EvaluationContext = selfRef as? EvaluationContext ?: return set
|
||||
while(true) {
|
||||
set.addAll(currentRef.valueGetter())
|
||||
currentRef = currentRef.parent ?: break
|
||||
}
|
||||
return set
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,30 @@
|
|||
package org.nwapw.abacus.context
|
||||
|
||||
import org.nwapw.abacus.exception.ContextException
|
||||
import kotlin.reflect.KProperty
|
||||
|
||||
/**
|
||||
* A delegate to search a hierarchy made up of [EvaluationContext].
|
||||
*
|
||||
* ChainSearchDelegate is a variable delegate written specifically for use in [EvaluationContext], because
|
||||
* of its hierarchical structure. Variables not found in the current context are searched
|
||||
* for in its parent, which continues recursively until the context being examined has no parent.
|
||||
* This class assists that logic, which is commonly re-used with different variable types, by calling
|
||||
* [valueGetter] on the current context, then its parent, etc.
|
||||
*
|
||||
* @param V the type of the property to search recursively.
|
||||
* @property valueGetter the getter lambda to access the value from the context.
|
||||
*/
|
||||
class ChainSearchDelegate<out V>(private val valueGetter: EvaluationContext.() -> V?) {
|
||||
|
||||
operator fun getValue(selfRef: Any, property: KProperty<*>): V {
|
||||
var currentRef = selfRef as EvaluationContext
|
||||
var returnedValue = currentRef.valueGetter()
|
||||
while (returnedValue == null) {
|
||||
currentRef = currentRef.parent ?: break
|
||||
returnedValue = currentRef.valueGetter()
|
||||
}
|
||||
return returnedValue ?: throw ContextException("context chain does not contain value")
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,85 @@
|
|||
package org.nwapw.abacus.context
|
||||
|
||||
import org.nwapw.abacus.Abacus
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.plugin.NumberImplementation
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
|
||||
/**
|
||||
* A context for the reduction of a [org.nwapw.abacus.tree.TreeNode] into a number.
|
||||
*
|
||||
* The reduction context is used to carry important state information captured at the beginning
|
||||
* of the reduction of an expression, such as the variables and the implementation in use.
|
||||
*
|
||||
* @property parent the parent of this context.
|
||||
* @property numberImplementation the implementation for numbers of this context.
|
||||
* @property abacus the abacus instance used by this reducer.
|
||||
*/
|
||||
abstract class EvaluationContext(val parent: EvaluationContext? = null,
|
||||
open val numberImplementation: NumberImplementation? = null,
|
||||
open val abacus: Abacus? = null): Reducer<NumberInterface> {
|
||||
|
||||
/**
|
||||
* The map of variables in this context.
|
||||
*/
|
||||
protected val variableMap = mutableMapOf<String, NumberInterface>()
|
||||
/**
|
||||
* The map of definitions in this context.
|
||||
*/
|
||||
protected val definitionMap = mutableMapOf<String, TreeNode>()
|
||||
|
||||
/**
|
||||
* The set of all variable names defined in this context.
|
||||
*/
|
||||
val variables: Set<String>
|
||||
get() = variableMap.keys
|
||||
|
||||
/**
|
||||
* The set of all definition names defined in this context.
|
||||
*/
|
||||
val definitions: Set<String>
|
||||
get() = definitionMap.keys
|
||||
|
||||
/**
|
||||
* The implementation inherited from this context's parent.
|
||||
*/
|
||||
val inheritedNumberImplementation: NumberImplementation
|
||||
by ChainSearchDelegate { numberImplementation }
|
||||
|
||||
/**
|
||||
* The Abacus instance inherited from this context's parent.
|
||||
*/
|
||||
val inheritedAbacus: Abacus
|
||||
by ChainSearchDelegate { abacus }
|
||||
|
||||
/**
|
||||
* The set of all variables in this context and its parents.
|
||||
*/
|
||||
val inheritedVariables: Set<String> by ChainAccumulateDelegate { variables }
|
||||
|
||||
/**
|
||||
* The set of all definition in this context and its parents.
|
||||
*/
|
||||
val inheritedDefinitions: Set<String> by ChainAccumulateDelegate { definitions }
|
||||
|
||||
/**
|
||||
* Create a new child instance of this context that is mutable.
|
||||
* @return the new child instance.
|
||||
*/
|
||||
fun mutableSubInstance(): MutableEvaluationContext = MutableEvaluationContext(this)
|
||||
|
||||
/**
|
||||
* Gets a variable stored in this context.
|
||||
*/
|
||||
fun getVariable(name: String): NumberInterface? {
|
||||
return variableMap[name] ?: parent?.getVariable(name)
|
||||
}
|
||||
/**
|
||||
* Gets the definition stored in this context.
|
||||
*/
|
||||
fun getDefinition(name: String): TreeNode? {
|
||||
return definitionMap[name] ?: parent?.getDefinition(name)
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,91 @@
|
|||
package org.nwapw.abacus.context
|
||||
|
||||
import org.nwapw.abacus.Abacus
|
||||
import org.nwapw.abacus.exception.NumberReducerException
|
||||
import org.nwapw.abacus.exception.ReductionException
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.plugin.NumberImplementation
|
||||
import org.nwapw.abacus.tree.nodes.*
|
||||
|
||||
/**
|
||||
* A reduction context that is mutable.
|
||||
*
|
||||
* @param parent the parent of this context.
|
||||
* @param numberImplementation the number implementation used in this context.
|
||||
* @param abacus the abacus instance used.
|
||||
*/
|
||||
class MutableEvaluationContext(parent: EvaluationContext? = null,
|
||||
numberImplementation: NumberImplementation? = null,
|
||||
abacus: Abacus? = null) :
|
||||
PluginEvaluationContext(parent, numberImplementation, abacus) {
|
||||
|
||||
override var numberImplementation: NumberImplementation? = super.numberImplementation
|
||||
override var abacus: Abacus? = super.abacus
|
||||
|
||||
/**
|
||||
* Writes data stored in the [other] context over data stored in this one.
|
||||
* @param other the context from which to copy data.
|
||||
*/
|
||||
fun apply(other: EvaluationContext) {
|
||||
if(other.numberImplementation != null) numberImplementation = other.numberImplementation
|
||||
for(name in other.variables) {
|
||||
setVariable(name, other.getVariable(name) ?: continue)
|
||||
}
|
||||
for(name in other.definitions) {
|
||||
setDefinition(name, other.getDefinition(name) ?: continue)
|
||||
}
|
||||
}
|
||||
|
||||
override fun reduceNode(treeNode: TreeNode, vararg children: Any): NumberInterface {
|
||||
val oldNumberImplementation = numberImplementation
|
||||
val abacus = inheritedAbacus
|
||||
val promotionManager = abacus.promotionManager
|
||||
val toReturn = when(treeNode){
|
||||
is NumberNode -> {
|
||||
inheritedNumberImplementation.instanceForString(treeNode.number)
|
||||
}
|
||||
is VariableNode -> {
|
||||
val variable = getVariable(treeNode.variable)
|
||||
if(variable != null) return variable
|
||||
val definition = getDefinition(treeNode.variable)
|
||||
if(definition != null) return definition.reduce(this)
|
||||
throw NumberReducerException("variable is not defined.")
|
||||
}
|
||||
is NumberUnaryNode -> {
|
||||
val child = children[0] as NumberInterface
|
||||
numberImplementation = abacus.pluginManager.interfaceImplementationFor(child.javaClass)
|
||||
abacus.pluginManager.operatorFor(treeNode.operation)
|
||||
.apply(this, child)
|
||||
}
|
||||
is NumberBinaryNode -> {
|
||||
val left = children[0] as NumberInterface
|
||||
val right = children[1] as NumberInterface
|
||||
val promotionResult = promotionManager.promote(left, right)
|
||||
numberImplementation = promotionResult.promotedTo
|
||||
abacus.pluginManager.operatorFor(treeNode.operation).apply(this, *promotionResult.items)
|
||||
}
|
||||
is NumberFunctionNode -> {
|
||||
val promotionResult = promotionManager
|
||||
.promote(*children.map { it as NumberInterface }.toTypedArray())
|
||||
numberImplementation = promotionResult.promotedTo
|
||||
abacus.pluginManager.functionFor(treeNode.callTo).apply(this, *promotionResult.items)
|
||||
}
|
||||
is TreeValueUnaryNode -> {
|
||||
abacus.pluginManager.treeValueOperatorFor(treeNode.operation)
|
||||
.apply(this, treeNode.applyTo)
|
||||
}
|
||||
is TreeValueBinaryNode -> {
|
||||
abacus.pluginManager.treeValueOperatorFor(treeNode.operation)
|
||||
.apply(this, treeNode.left, treeNode.right)
|
||||
}
|
||||
is TreeValueFunctionNode -> {
|
||||
abacus.pluginManager.treeValueFunctionFor(treeNode.callTo)
|
||||
.apply(this, *treeNode.children.toTypedArray())
|
||||
}
|
||||
else -> throw ReductionException("unrecognized tree node.")
|
||||
}
|
||||
numberImplementation = oldNumberImplementation
|
||||
return toReturn
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,58 @@
|
|||
package org.nwapw.abacus.context
|
||||
|
||||
import org.nwapw.abacus.Abacus
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.plugin.NumberImplementation
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
|
||||
/**
|
||||
* An evaluation context with limited mutability.
|
||||
*
|
||||
* An evaluation context that is mutable but in a limited way, that is, not allowing the modifications
|
||||
* of variables whose changes might cause issues outside of the function. An example of this would be
|
||||
* the modification of the [numberImplementation], which would cause code paths such as the parsing
|
||||
* of NumberNodes to produce a different type of number than if the function did not run, whcih is unacceptable.
|
||||
*
|
||||
* @param parent the parent of this context.
|
||||
* @param numberImplementation the number implementation used in this context.
|
||||
* @param abacus the abacus instance used.
|
||||
*/
|
||||
abstract class PluginEvaluationContext(parent: EvaluationContext? = null,
|
||||
numberImplementation: NumberImplementation? = null,
|
||||
abacus: Abacus? = null) :
|
||||
EvaluationContext(parent, numberImplementation, abacus) {
|
||||
|
||||
/**
|
||||
* Sets a variable to a certain [value].
|
||||
* @param name the name of the variable.
|
||||
* @param value the value of the variable.
|
||||
*/
|
||||
fun setVariable(name: String, value: NumberInterface) {
|
||||
variableMap[name] = value
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a definition to a certain [value].
|
||||
* @param name the name of the definition.
|
||||
* @param value the value of the definition.
|
||||
*/
|
||||
fun setDefinition(name: String, value: TreeNode) {
|
||||
definitionMap[name] = value
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the variables defined in this context.
|
||||
*/
|
||||
fun clearVariables(){
|
||||
variableMap.clear()
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the definitions defined in this context.
|
||||
*/
|
||||
fun clearDefinitions(){
|
||||
definitionMap.clear()
|
||||
}
|
||||
|
||||
|
||||
}
|
|
@ -0,0 +1,45 @@
|
|||
package org.nwapw.abacus.function
|
||||
|
||||
import org.nwapw.abacus.context.MutableEvaluationContext
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.exception.DomainException
|
||||
|
||||
/**
|
||||
* A class that can be applied to arguments.
|
||||
*
|
||||
* Applicable is a class that represents something that can be applied to one or more
|
||||
* arguments of the same type, and returns a single value from that application.
|
||||
* @param <T> the type of the parameters passed to this applicable.
|
||||
* @param <O> the return type of the applicable.
|
||||
*/
|
||||
interface Applicable<in T : Any, out O : Any> {
|
||||
|
||||
/**
|
||||
* Checks if the given applicable can be used with the given parameters.
|
||||
* @param params the parameter array to verify for compatibility.
|
||||
* @return whether the array can be used with applyInternal.
|
||||
*/
|
||||
fun matchesParams(context: PluginEvaluationContext, params: Array<out T>): Boolean
|
||||
|
||||
/**
|
||||
* Applies the applicable object to the given parameters,
|
||||
* without checking for compatibility.
|
||||
* @param params the parameters to apply to.
|
||||
* @return the result of the application.
|
||||
*/
|
||||
fun applyInternal(context: PluginEvaluationContext, params: Array<out T>): O
|
||||
|
||||
/**
|
||||
* If the parameters can be used with this applicable, returns
|
||||
* the result of the application of the applicable to the parameters.
|
||||
* Otherwise, returns null.
|
||||
* @param params the parameters to apply to.
|
||||
* @return the result of the operation, or null if parameters do not match.
|
||||
*/
|
||||
fun apply(context: PluginEvaluationContext, vararg params: T): O {
|
||||
if (!matchesParams(context, params))
|
||||
throw DomainException("parameters do not match function requirements.")
|
||||
return applyInternal(context, params)
|
||||
}
|
||||
|
||||
}
|
|
@ -3,12 +3,11 @@ package org.nwapw.abacus.function
|
|||
/**
|
||||
* A single operator that can be used by Abacus.
|
||||
*
|
||||
* This is a data class that holds the information about a single operator, such as a plus or minus.
|
||||
* This is a class that holds the information about a single operator, such as a plus or minus.
|
||||
*
|
||||
* @param associativity the associativity of this operator, used for order of operations;.
|
||||
* @param type the type of this operator, used for parsing (infix / prefix / postfix and binary / unary)
|
||||
* @param precedence the precedence of this operator, used for order of operations.
|
||||
* @param function the function this operator applies to its arguments.
|
||||
*/
|
||||
data class Operator(val associativity: OperatorAssociativity, val type: OperatorType,
|
||||
val precedence: Int, val function: Function)
|
||||
open class Operator(val associativity: OperatorAssociativity, val type: OperatorType,
|
||||
val precedence: Int)
|
|
@ -0,0 +1,12 @@
|
|||
package org.nwapw.abacus.function.interfaces
|
||||
|
||||
import org.nwapw.abacus.function.Applicable
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* A function that operates on numbers.
|
||||
*
|
||||
* This function takes some number of input NumberInterfaces and returns
|
||||
* another NumberInterface as a result.
|
||||
*/
|
||||
abstract class NumberFunction : Applicable<NumberInterface, NumberInterface>
|
|
@ -0,0 +1,20 @@
|
|||
package org.nwapw.abacus.function.interfaces
|
||||
|
||||
import org.nwapw.abacus.function.Applicable
|
||||
import org.nwapw.abacus.function.Operator
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* An operator that operates on NumberImplementations.
|
||||
*
|
||||
* This is simply an alias for Operator<NumberInterface, NumberInterface>.
|
||||
* @param associativity the associativity of the operator.
|
||||
* @param type the type of the operator (binary, unary, etc)
|
||||
* @param precedence the precedence of the operator.
|
||||
*/
|
||||
abstract class NumberOperator(associativity: OperatorAssociativity, type: OperatorType,
|
||||
precedence: Int) :
|
||||
Operator(associativity, type, precedence),
|
||||
Applicable<NumberInterface, NumberInterface>
|
|
@ -0,0 +1,13 @@
|
|||
package org.nwapw.abacus.function.interfaces
|
||||
|
||||
import org.nwapw.abacus.function.Applicable
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
|
||||
/**
|
||||
* A function that operates on trees.
|
||||
*
|
||||
* 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 : Applicable<TreeNode, NumberInterface>
|
|
@ -0,0 +1,21 @@
|
|||
package org.nwapw.abacus.function.interfaces
|
||||
|
||||
import org.nwapw.abacus.function.Applicable
|
||||
import org.nwapw.abacus.function.Operator
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
|
||||
/**
|
||||
* An operator that operates on trees.
|
||||
*
|
||||
* This operator operates on parse trees, returning, however a number.
|
||||
* @param associativity the associativity of the operator.
|
||||
* @param type the type of the operator (infix, postfix, etc)
|
||||
* @param precedence the precedence of the operator.
|
||||
*/
|
||||
abstract class TreeValueOperator(associativity: OperatorAssociativity, type: OperatorType,
|
||||
precedence: Int) :
|
||||
Operator(associativity, type, precedence),
|
||||
Applicable<TreeNode, NumberInterface>
|
546
core/src/main/java/org/nwapw/abacus/number/NumberInterface.java → core/src/main/kotlin/org/nwapw/abacus/number/NumberInterface.kt
Executable file → Normal file
546
core/src/main/java/org/nwapw/abacus/number/NumberInterface.java → core/src/main/kotlin/org/nwapw/abacus/number/NumberInterface.kt
Executable file → Normal file
|
@ -1,270 +1,276 @@
|
|||
package org.nwapw.abacus.number;
|
||||
|
||||
/**
|
||||
* An interface used to represent a number.
|
||||
*/
|
||||
public abstract class NumberInterface {
|
||||
|
||||
/**
|
||||
* Check if the thread was interrupted and
|
||||
* throw an exception to end the computation.
|
||||
*/
|
||||
private static void checkInterrupted() {
|
||||
if (Thread.currentThread().isInterrupted())
|
||||
throw new ComputationInterruptedException();
|
||||
}
|
||||
|
||||
/**
|
||||
* The maximum precision to which this number operates.
|
||||
*
|
||||
* @return the precision.
|
||||
*/
|
||||
public abstract int getMaxPrecision();
|
||||
|
||||
/**
|
||||
* Multiplies this number by another, returning
|
||||
* a new number instance.
|
||||
*
|
||||
* @param multiplier the multiplier
|
||||
* @return the result of the multiplication.
|
||||
*/
|
||||
protected abstract NumberInterface multiplyInternal(NumberInterface multiplier);
|
||||
|
||||
/**
|
||||
* Multiplies this number by another, returning
|
||||
* a new number instance. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param multiplier the multiplier
|
||||
* @return the result of the multiplication.
|
||||
*/
|
||||
public final NumberInterface multiply(NumberInterface multiplier) {
|
||||
checkInterrupted();
|
||||
return multiplyInternal(multiplier);
|
||||
}
|
||||
|
||||
/**
|
||||
* Divides this number by another, returning
|
||||
* a new number instance.
|
||||
*
|
||||
* @param divisor the divisor
|
||||
* @return the result of the division.
|
||||
*/
|
||||
protected abstract NumberInterface divideInternal(NumberInterface divisor);
|
||||
|
||||
/**
|
||||
* Divides this number by another, returning
|
||||
* a new number instance. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param divisor the divisor
|
||||
* @return the result of the division.
|
||||
*/
|
||||
public final NumberInterface divide(NumberInterface divisor) {
|
||||
checkInterrupted();
|
||||
return divideInternal(divisor);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds this number to another, returning
|
||||
* a new number instance.
|
||||
*
|
||||
* @param summand the summand
|
||||
* @return the result of the summation.
|
||||
*/
|
||||
protected abstract NumberInterface addInternal(NumberInterface summand);
|
||||
|
||||
/**
|
||||
* Adds this number to another, returning
|
||||
* a new number instance. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param summand the summand
|
||||
* @return the result of the summation.
|
||||
*/
|
||||
public final NumberInterface add(NumberInterface summand) {
|
||||
checkInterrupted();
|
||||
return addInternal(summand);
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts another number from this number,
|
||||
* a new number instance.
|
||||
*
|
||||
* @param subtrahend the subtrahend.
|
||||
* @return the result of the subtraction.
|
||||
*/
|
||||
protected abstract NumberInterface subtractInternal(NumberInterface subtrahend);
|
||||
|
||||
/**
|
||||
* Subtracts another number from this number,
|
||||
* a new number instance. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param subtrahend the subtrahend.
|
||||
* @return the result of the subtraction.
|
||||
*/
|
||||
public final NumberInterface subtract(NumberInterface subtrahend) {
|
||||
checkInterrupted();
|
||||
return subtractInternal(subtrahend);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a new instance of this number with
|
||||
* the sign flipped.
|
||||
*
|
||||
* @return the new instance.
|
||||
*/
|
||||
protected abstract NumberInterface negateInternal();
|
||||
|
||||
|
||||
/**
|
||||
* Returns a new instance of this number with
|
||||
* the sign flipped. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @return the new instance.
|
||||
*/
|
||||
public final NumberInterface negate() {
|
||||
checkInterrupted();
|
||||
return negateInternal();
|
||||
}
|
||||
|
||||
/**
|
||||
* Raises this number to an integer power.
|
||||
*
|
||||
* @param exponent the exponent to which to take the number.
|
||||
* @return the resulting value.
|
||||
*/
|
||||
protected abstract NumberInterface intPowInternal(int exponent);
|
||||
|
||||
/**
|
||||
* Raises this number to an integer power. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param exponent the exponent to which to take the number.
|
||||
* @return the resulting value.
|
||||
*/
|
||||
public final NumberInterface intPow(int exponent) {
|
||||
checkInterrupted();
|
||||
return intPowInternal(exponent);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares this number to another.
|
||||
*
|
||||
* @param number the number to compare to.
|
||||
* @return same as Integer.compare();
|
||||
*/
|
||||
public abstract int compareTo(NumberInterface number);
|
||||
|
||||
/**
|
||||
* Same as Math.signum().
|
||||
*
|
||||
* @return 1 if this number is positive, -1 if this number is negative, 0 if this number is 0.
|
||||
*/
|
||||
public abstract int signum();
|
||||
|
||||
/**
|
||||
* Returns the least integer greater than or equal to the number.
|
||||
*
|
||||
* @return the least integer greater or equal to the number, if int can hold the value.
|
||||
*/
|
||||
protected abstract NumberInterface ceilingInternal();
|
||||
|
||||
/**
|
||||
* Returns the least integer greater than or equal to the number.
|
||||
* Also, checks if the thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @return the least integer bigger or equal to the number.
|
||||
*/
|
||||
public final NumberInterface ceiling() {
|
||||
checkInterrupted();
|
||||
return ceilingInternal();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the greatest integer less than or equal to the number.
|
||||
*
|
||||
* @return the greatest integer smaller or equal the number.
|
||||
*/
|
||||
protected abstract NumberInterface floorInternal();
|
||||
|
||||
/**
|
||||
* Return the greatest integer less than or equal to the number.
|
||||
* Also, checks if the thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @return the greatest int smaller than or equal to the number.
|
||||
*/
|
||||
public final NumberInterface floor() {
|
||||
checkInterrupted();
|
||||
return floorInternal();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the fractional part of the number.
|
||||
*
|
||||
* @return the fractional part of the number.
|
||||
*/
|
||||
protected abstract NumberInterface fractionalPartInternal();
|
||||
|
||||
/**
|
||||
* Returns the fractional part of the number, specifically x - floor(x).
|
||||
* Also, checks if the thread has been interrupted,
|
||||
* and if so, throws an exception.
|
||||
*
|
||||
* @return the fractional part of the number.
|
||||
*/
|
||||
public final NumberInterface fractionalPart() {
|
||||
checkInterrupted();
|
||||
return fractionalPartInternal();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the integer representation of this number, discarding any fractional part,
|
||||
* if int can hold the value.
|
||||
*
|
||||
* @return the integer value of this number.
|
||||
*/
|
||||
public abstract int intValue();
|
||||
|
||||
/**
|
||||
* Promotes this class to another number class.
|
||||
*
|
||||
* @param toClass the class to promote to.
|
||||
* @return the resulting new instance.
|
||||
*/
|
||||
@Deprecated
|
||||
protected abstract NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass);
|
||||
|
||||
/**
|
||||
* Promotes this class to another number class. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param toClass the class to promote to.
|
||||
* @return the resulting new instance.
|
||||
*/
|
||||
@Deprecated
|
||||
public final NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
|
||||
checkInterrupted();
|
||||
return promoteToInternal(toClass);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the smallest error this instance can tolerate depending
|
||||
* on its precision and value.
|
||||
*
|
||||
* @return the smallest error that should be permitted in calculations.
|
||||
*/
|
||||
public abstract NumberInterface getMaxError();
|
||||
|
||||
}
|
||||
package org.nwapw.abacus.number
|
||||
|
||||
import org.nwapw.abacus.exception.ComputationInterruptedException
|
||||
import org.nwapw.abacus.number.range.NumberRangeBuilder
|
||||
|
||||
abstract class NumberInterface: Comparable<NumberInterface> {
|
||||
|
||||
/**
|
||||
* Check if the thread was interrupted and
|
||||
* throw an exception to end the computation.
|
||||
*/
|
||||
private fun checkInterrupted(){
|
||||
if(Thread.currentThread().isInterrupted)
|
||||
throw ComputationInterruptedException()
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the integer representation of this number, discarding any fractional part,
|
||||
* if int can hold the value.
|
||||
*
|
||||
* @return the integer value of this number.
|
||||
*/
|
||||
abstract fun intValue(): Int
|
||||
/**
|
||||
* Same as Math.signum().
|
||||
*
|
||||
* @return 1 if this number is positive, -1 if this number is negative, 0 if this number is 0.
|
||||
*/
|
||||
abstract fun signum(): Int
|
||||
|
||||
/**
|
||||
* The maximum precision to which this number operates.
|
||||
*/
|
||||
abstract val maxPrecision: Int
|
||||
/**
|
||||
* Returns the smallest error this instance can tolerate depending
|
||||
* on its precision and value.
|
||||
*/
|
||||
abstract val maxError: NumberInterface
|
||||
|
||||
/**
|
||||
* Adds this number to another, returning
|
||||
* a new number instance.
|
||||
*
|
||||
* @param summand the summand
|
||||
* @return the result of the summation.
|
||||
*/
|
||||
abstract fun addInternal(summand: NumberInterface): NumberInterface
|
||||
/**
|
||||
* Subtracts another number from this number,
|
||||
* a new number instance.
|
||||
*
|
||||
* @param subtrahend the subtrahend.
|
||||
* @return the result of the subtraction.
|
||||
*/
|
||||
abstract fun subtractInternal(subtrahend: NumberInterface): NumberInterface
|
||||
/**
|
||||
* Multiplies this number by another, returning
|
||||
* a new number instance.
|
||||
*
|
||||
* @param multiplier the multiplier
|
||||
* @return the result of the multiplication.
|
||||
*/
|
||||
abstract fun multiplyInternal(multiplier: NumberInterface): NumberInterface
|
||||
/**
|
||||
* Divides this number by another, returning
|
||||
* a new number instance.
|
||||
*
|
||||
* @param divisor the divisor
|
||||
* @return the result of the division.
|
||||
*/
|
||||
abstract fun divideInternal(divisor: NumberInterface): NumberInterface
|
||||
/**
|
||||
* Returns a new instance of this number with
|
||||
* the sign flipped.
|
||||
*
|
||||
* @return the new instance.
|
||||
*/
|
||||
abstract fun negateInternal(): NumberInterface
|
||||
/**
|
||||
* Raises this number to an integer power.
|
||||
*
|
||||
* @param exponent the exponent to which to take the number.
|
||||
* @return the resulting value.
|
||||
*/
|
||||
abstract fun intPowInternal(pow: Int): NumberInterface
|
||||
/**
|
||||
* Returns the least integer greater than or equal to the number.
|
||||
*
|
||||
* @return the least integer greater or equal to the number, if int can hold the value.
|
||||
*/
|
||||
abstract fun ceilingInternal(): NumberInterface
|
||||
/**
|
||||
* Return the greatest integer less than or equal to the number.
|
||||
*
|
||||
* @return the greatest integer smaller or equal the number.
|
||||
*/
|
||||
abstract fun floorInternal(): NumberInterface
|
||||
/**
|
||||
* Returns the fractional part of the number.
|
||||
*
|
||||
* @return the fractional part of the number.
|
||||
*/
|
||||
abstract fun fractionalPartInternal(): NumberInterface
|
||||
|
||||
/**
|
||||
* Adds this number to another, returning
|
||||
* a new number instance. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param summand the summand
|
||||
* @return the result of the summation.
|
||||
*/
|
||||
fun add(summand: NumberInterface): NumberInterface {
|
||||
checkInterrupted()
|
||||
return addInternal(summand)
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts another number from this number,
|
||||
* a new number instance. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param subtrahend the subtrahend.
|
||||
* @return the result of the subtraction.
|
||||
*/
|
||||
fun subtract(subtrahend: NumberInterface): NumberInterface {
|
||||
checkInterrupted()
|
||||
return subtractInternal(subtrahend)
|
||||
}
|
||||
|
||||
/**
|
||||
* Multiplies this number by another, returning
|
||||
* a new number instance. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param multiplier the multiplier
|
||||
* @return the result of the multiplication.
|
||||
*/
|
||||
fun multiply(multiplier: NumberInterface): NumberInterface {
|
||||
checkInterrupted()
|
||||
return multiplyInternal(multiplier)
|
||||
}
|
||||
|
||||
/**
|
||||
* Divides this number by another, returning
|
||||
* a new number instance. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param divisor the divisor
|
||||
* @return the result of the division.
|
||||
*/
|
||||
fun divide(divisor: NumberInterface): NumberInterface {
|
||||
checkInterrupted()
|
||||
return divideInternal(divisor)
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a new instance of this number with
|
||||
* the sign flipped. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @return the new instance.
|
||||
*/
|
||||
fun negate(): NumberInterface {
|
||||
checkInterrupted()
|
||||
return negateInternal()
|
||||
}
|
||||
|
||||
/**
|
||||
* Raises this number to an integer power. Also, checks if the
|
||||
* thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @param exponent the exponent to which to take the number.
|
||||
* @return the resulting value.
|
||||
*/
|
||||
fun intPow(exponent: Int): NumberInterface {
|
||||
checkInterrupted()
|
||||
return intPowInternal(exponent)
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the least integer greater than or equal to the number.
|
||||
* Also, checks if the thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @return the least integer bigger or equal to the number.
|
||||
*/
|
||||
fun ceiling(): NumberInterface {
|
||||
checkInterrupted()
|
||||
return ceilingInternal()
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the greatest integer less than or equal to the number.
|
||||
* Also, checks if the thread has been interrupted, and if so, throws
|
||||
* an exception.
|
||||
*
|
||||
* @return the greatest int smaller than or equal to the number.
|
||||
*/
|
||||
fun floor(): NumberInterface {
|
||||
checkInterrupted()
|
||||
return floorInternal()
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the fractional part of the number, specifically x - floor(x).
|
||||
* Also, checks if the thread has been interrupted,
|
||||
* and if so, throws an exception.
|
||||
*
|
||||
* @return the fractional part of the number.
|
||||
*/
|
||||
fun fractionalPart(): NumberInterface {
|
||||
checkInterrupted()
|
||||
return fractionalPartInternal()
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given number is an integer or not.
|
||||
*
|
||||
* @return whether the number is an integer or not.
|
||||
*/
|
||||
fun isInteger() = fractionalPart().signum() == 0
|
||||
|
||||
/**
|
||||
* Returns a NumberRangeBuilder object, which is used to create a range.
|
||||
* The reason that this returns a builder and not an actual range is that
|
||||
* the NumberRange needs to promote values passed to it, which
|
||||
* requires an abacus instance.
|
||||
* @param other the value at the bottom of the range.
|
||||
* @return the resulting range builder.
|
||||
*/
|
||||
operator fun rangeTo(other: NumberInterface) = NumberRangeBuilder(this, other)
|
||||
|
||||
/**
|
||||
* Plus operator overloaded to allow "nice" looking math.
|
||||
* @param other the value to add to this number.
|
||||
* @return the result of the addition.
|
||||
*/
|
||||
operator fun plus(other: NumberInterface) = add(other)
|
||||
/**
|
||||
* Minus operator overloaded to allow "nice" looking math.
|
||||
* @param other the value to subtract to this number.
|
||||
* @return the result of the subtraction.
|
||||
*/
|
||||
operator fun minus(other: NumberInterface) = subtract(other)
|
||||
/**
|
||||
* Times operator overloaded to allow "nice" looking math.
|
||||
* @param other the value to multiply this number by.
|
||||
* @return the result of the multiplication.
|
||||
*/
|
||||
operator fun times(other: NumberInterface) = multiply(other)
|
||||
/**
|
||||
* Divide operator overloaded to allow "nice" looking math.
|
||||
* @param other the value to divide this number by.
|
||||
* @return the result of the division.
|
||||
*/
|
||||
operator fun div(other: NumberInterface) = divide(other)
|
||||
/**
|
||||
* The plus operator.
|
||||
* @return this number.
|
||||
*/
|
||||
operator fun unaryPlus() = this
|
||||
/**
|
||||
* The minus operator.
|
||||
* @return the negative of this number.
|
||||
*/
|
||||
operator fun unaryMinus() = negate()
|
||||
|
||||
}
|
|
@ -0,0 +1,17 @@
|
|||
@file:JvmName("NumberUtils")
|
||||
package org.nwapw.abacus.number.promotion
|
||||
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
typealias PromotionPath = List<PromotionFunction>
|
||||
typealias NumberClass = Class<NumberInterface>
|
||||
|
||||
/**
|
||||
* Promote a number through this path. The functions in this path
|
||||
* are applied in order to the number, and the final result is returned.
|
||||
*
|
||||
* @param from the number to start from.
|
||||
*/
|
||||
fun PromotionPath.promote(from: NumberInterface): NumberInterface {
|
||||
return fold(from, { current, function -> function.promote(current) })
|
||||
}
|
|
@ -0,0 +1,20 @@
|
|||
package org.nwapw.abacus.number.promotion
|
||||
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* Function that is used to promote a number from one type to another.
|
||||
*
|
||||
* A promotion function is used in the promotion system as a mean to
|
||||
* actually "travel" down the promotion path.
|
||||
*/
|
||||
interface PromotionFunction {
|
||||
|
||||
/**
|
||||
* Promotes the given [number] into another type.
|
||||
* @param number the number to promote from.
|
||||
* @return the new number with the same value.
|
||||
*/
|
||||
fun promote(number: NumberInterface): NumberInterface
|
||||
|
||||
}
|
|
@ -0,0 +1,81 @@
|
|||
package org.nwapw.abacus.number.promotion
|
||||
|
||||
import org.nwapw.abacus.Abacus
|
||||
import org.nwapw.abacus.exception.PromotionException
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.plugin.NumberImplementation
|
||||
import org.nwapw.abacus.plugin.PluginListener
|
||||
import org.nwapw.abacus.plugin.PluginManager
|
||||
|
||||
/**
|
||||
* A class that handles promotions based on priority and the
|
||||
* transition paths each implementation provides.
|
||||
*
|
||||
* @property abacus the Abacus instance to use to access other components.
|
||||
*/
|
||||
class PromotionManager(val abacus: Abacus) : PluginListener {
|
||||
|
||||
/**
|
||||
* The already computed paths
|
||||
*/
|
||||
val computePaths = mutableMapOf<Pair<NumberImplementation, NumberImplementation>, PromotionPath?>()
|
||||
|
||||
/**
|
||||
* Computes a path between a starting and an ending implementation.
|
||||
*
|
||||
* @param from the implementation to start from.
|
||||
* @param to the implementation to get to.
|
||||
* @return the resulting promotion path, or null if it is not found
|
||||
*/
|
||||
fun computePathBetween(from: NumberImplementation, to: NumberImplementation): PromotionPath? {
|
||||
val fromName = abacus.pluginManager.interfaceImplementationNameFor(from.implementation)
|
||||
val toName = abacus.pluginManager.interfaceImplementationNameFor(to.implementation)
|
||||
|
||||
if(fromName == toName) return listOf(object : PromotionFunction {
|
||||
override fun promote(number: NumberInterface): NumberInterface {
|
||||
return number
|
||||
}
|
||||
})
|
||||
|
||||
if(from.promotionPaths.containsKey(toName))
|
||||
return listOf(from.promotionPaths[toName] ?: return null)
|
||||
return null
|
||||
}
|
||||
|
||||
/**
|
||||
* Promote all the numbers in the list to the same number implementation, to ensure
|
||||
* they can be used with each other. Finds the highest priority implementation
|
||||
* in the list, and promotes all other numbers to it.
|
||||
*
|
||||
* @param numbers the numbers to promote.
|
||||
* @return the resulting promotion result.
|
||||
*/
|
||||
fun promote(vararg numbers: NumberInterface): PromotionResult {
|
||||
val pluginManager = abacus.pluginManager
|
||||
val implementations = numbers.map { pluginManager.interfaceImplementationFor(it.javaClass) }
|
||||
val highestPriority = implementations.sortedBy { it.priority }.last()
|
||||
return PromotionResult(items = numbers.map {
|
||||
if (it.javaClass == highestPriority.implementation) it
|
||||
else computePaths[pluginManager.interfaceImplementationFor(it.javaClass) to highestPriority]
|
||||
?.promote(it) ?: throw PromotionException()
|
||||
}.toTypedArray(), promotedTo = highestPriority)
|
||||
}
|
||||
|
||||
override fun onLoad(manager: PluginManager) {
|
||||
val implementations = manager.allNumberImplementations.map { manager.numberImplementationFor(it) }
|
||||
for(first in implementations) {
|
||||
for(second in implementations) {
|
||||
val promoteFrom = if(second.priority > first.priority) first else second
|
||||
val promoteTo = if(second.priority > first.priority) second else first
|
||||
val path = computePathBetween(promoteFrom, promoteTo)
|
||||
computePaths[promoteFrom to promoteTo] = path
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun onUnload(manager: PluginManager) {
|
||||
computePaths.clear()
|
||||
}
|
||||
|
||||
|
||||
}
|
|
@ -0,0 +1,12 @@
|
|||
package org.nwapw.abacus.number.promotion
|
||||
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.plugin.NumberImplementation
|
||||
|
||||
/**
|
||||
* The result of promoting an array of NumberInterfaces.
|
||||
*
|
||||
* @param promotedTo the implementation to which the numbers were promoted.
|
||||
* @param items the items the items resulting from the promotion.
|
||||
*/
|
||||
data class PromotionResult(val promotedTo: NumberImplementation, val items: Array<NumberInterface>)
|
|
@ -0,0 +1,29 @@
|
|||
package org.nwapw.abacus.number.range
|
||||
|
||||
import org.nwapw.abacus.Abacus
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* A closed range designed specifically for [NumberInterface]
|
||||
*
|
||||
* Besides providing the usual functionality of a [ClosedRange], this range
|
||||
* also handles promotion - that is, it's safe to use it with numbers of different
|
||||
* implementations, even as starting and ending points.
|
||||
*
|
||||
* @property abacus the abacus instance used for promotion.
|
||||
* @property start the starting point of the range.
|
||||
* @property endInclusive the ending point of the range.
|
||||
*/
|
||||
class NumberRange(val abacus: Abacus,
|
||||
override val start: NumberInterface,
|
||||
override val endInclusive: NumberInterface): ClosedRange<NumberInterface> {
|
||||
|
||||
override operator fun contains(value: NumberInterface): Boolean {
|
||||
val promotionResult = abacus.promotionManager.promote(start, endInclusive, value)
|
||||
val newStart = promotionResult.items[0]
|
||||
val newEnd = promotionResult.items[1]
|
||||
val newValue = promotionResult.items[2]
|
||||
return newValue >= newStart && newValue <= newEnd
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,25 @@
|
|||
package org.nwapw.abacus.number.range
|
||||
|
||||
import org.nwapw.abacus.Abacus
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* A utility class for creating [NumberRange] instances.
|
||||
*
|
||||
* Unlike a regular [ClosedRange], a NumberRange must have a third parameter,
|
||||
* which is the [Abacus] instance that is used for promotion. However, the ".." operator
|
||||
* is infix, and can only take two parameters. The solution is, instead of returning instances
|
||||
* of NumberRange directly, to return a builder, which then provides a [with] infix function
|
||||
* to attach it to an instance of Abacus.
|
||||
* @property start the beginning of the range.
|
||||
* @property endInclusive the end of the range.
|
||||
*/
|
||||
class NumberRangeBuilder(private val start: NumberInterface, private val endInclusive: NumberInterface) {
|
||||
|
||||
/**
|
||||
* Generate a [NumberRange] with the given instance of [abacus].
|
||||
* @return a new range with the given instance of Abacus.
|
||||
*/
|
||||
infix fun with(abacus: Abacus) = NumberRange(abacus, start, endInclusive)
|
||||
|
||||
}
|
|
@ -1,16 +1,17 @@
|
|||
package org.nwapw.abacus.parsing;
|
||||
package org.nwapw.abacus.parsing
|
||||
|
||||
import org.nwapw.abacus.tree.TreeNode;
|
||||
|
||||
import java.util.List;
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
|
||||
/**
|
||||
* An itnerface that provides the ability to convert a list of tokens
|
||||
* Converter from tokens into a parse tree.
|
||||
*
|
||||
* An interface that provides the ability to convert a list of tokens
|
||||
* into a parse tree.
|
||||
*
|
||||
* @param <T> the type of tokens accepted by this parser.
|
||||
*/
|
||||
public interface Parser<T> {
|
||||
|
||||
interface Parser<in T> {
|
||||
|
||||
/**
|
||||
* Constructs a tree out of the given tokens.
|
||||
|
@ -18,5 +19,6 @@ public interface Parser<T> {
|
|||
* @param tokens the tokens to construct a tree from.
|
||||
* @return the constructed tree, or null on error.
|
||||
*/
|
||||
public TreeNode constructTree(List<T> tokens);
|
||||
}
|
||||
fun constructTree(tokens: List<T>): TreeNode
|
||||
|
||||
}
|
|
@ -0,0 +1,21 @@
|
|||
package org.nwapw.abacus.parsing
|
||||
|
||||
/**
|
||||
* Converter from string to tokens.
|
||||
*
|
||||
* Interface that converts a string into a list
|
||||
* of tokens of a certain type.
|
||||
*
|
||||
* @param <T> the type of the tokens produced.
|
||||
*/
|
||||
interface Tokenizer<out T> {
|
||||
|
||||
/**
|
||||
* Converts a string into tokens.
|
||||
*
|
||||
* @param string the string to convert.
|
||||
* @return the list of tokens, or null on error.
|
||||
*/
|
||||
fun tokenizeString(string: String): List<T>
|
||||
|
||||
}
|
|
@ -0,0 +1,26 @@
|
|||
package org.nwapw.abacus.parsing
|
||||
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
|
||||
/**
|
||||
* Class to combine a [Tokenizer] and a [Parser]
|
||||
*
|
||||
* TreeBuilder class used to piece together a Tokenizer and
|
||||
* Parser of the same kind. This is used to essentially avoid
|
||||
* working with any parameters at all, and the generics
|
||||
* in this class are used only to ensure the tokenizer and parser
|
||||
* are of the same type.
|
||||
*
|
||||
* @param <T> the type of tokens created by the tokenizer and used by the parser.
|
||||
*/
|
||||
class TreeBuilder<T>(private val tokenizer: Tokenizer<T>, private val parser: Parser<T>) {
|
||||
|
||||
/**
|
||||
* Parses the given [string] into a tree.
|
||||
*
|
||||
* @param string the string to parse into a tree.
|
||||
* @return the resulting tree.
|
||||
*/
|
||||
fun fromString(string: String): TreeNode = parser.constructTree(tokenizer.tokenizeString(string))
|
||||
|
||||
}
|
|
@ -0,0 +1,21 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* The addition operator.
|
||||
*
|
||||
* This is a standard operator that simply performs addition.
|
||||
*/
|
||||
class OperatorAdd: NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params.size == 2
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params[0] + params[1]
|
||||
|
||||
}
|
|
@ -0,0 +1,38 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.plugin.standard.StandardPlugin.*
|
||||
|
||||
/**
|
||||
* The power operator.
|
||||
*
|
||||
* This is a standard operator that brings one number to the power of the other.
|
||||
*/
|
||||
class OperatorCaret: NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 3) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params.size == 2
|
||||
&& !(params[0].signum() == 0 && params[1].signum() == 0)
|
||||
&& !(params[0].signum() == -1 && !params[1].isInteger())
|
||||
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out NumberInterface>): NumberInterface {
|
||||
val implementation = context.inheritedNumberImplementation
|
||||
if (params[0].signum() == 0)
|
||||
return implementation.instanceForString("0")
|
||||
else if (params[1].signum() == 0)
|
||||
return implementation.instanceForString("1")
|
||||
//Detect integer bases:
|
||||
if (params[0].isInteger()
|
||||
&& FUNCTION_ABS.apply(context, params[1]) < implementation.instanceForString(Integer.toString(Integer.MAX_VALUE))
|
||||
&& FUNCTION_ABS.apply(context, params[1]) >= implementation.instanceForString("1")) {
|
||||
val newParams = arrayOf(params[0], params[1].fractionalPart())
|
||||
return params[0].intPow(params[1].floor().intValue()) * applyInternal(context, newParams)
|
||||
}
|
||||
return FUNCTION_EXP.apply(context, FUNCTION_LN.apply(context, FUNCTION_ABS.apply(context, params[0])) * params[1])
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,28 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.TreeValueOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
import org.nwapw.abacus.tree.nodes.VariableNode
|
||||
|
||||
/**
|
||||
* The definition operator.
|
||||
*
|
||||
* This is a standard operator that creates a definition - something that doesn't capture variable values
|
||||
* when it's created, but rather the variables themselves, and changes when the variables it uses change.
|
||||
*/
|
||||
class OperatorDefine: TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out TreeNode>) =
|
||||
params.size == 2 && params[0] is VariableNode
|
||||
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out TreeNode>): NumberInterface {
|
||||
val assignTo = (params[0] as VariableNode).variable
|
||||
context.setDefinition(assignTo, params[1])
|
||||
return params[1].reduce(context)
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,21 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* The division operator.
|
||||
*
|
||||
* This is a standard operator that simply performs division.
|
||||
*/
|
||||
class OperatorDivide: NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 2) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params.size == 2
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params[0] / params[1]
|
||||
|
||||
}
|
|
@ -0,0 +1,37 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* The factorial operator.
|
||||
*
|
||||
* This is a standard operator that simply evaluates the factorial of a number.
|
||||
*/
|
||||
class OperatorFactorial: NumberOperator(OperatorAssociativity.LEFT, OperatorType.UNARY_POSTFIX, 0) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params.size == 1
|
||||
&& params[0].isInteger()
|
||||
&& params[0].signum() >= 0
|
||||
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out NumberInterface>): NumberInterface {
|
||||
val implementation = context.inheritedNumberImplementation
|
||||
val one = implementation.instanceForString("1")
|
||||
if (params[0].signum() == 0) {
|
||||
return one
|
||||
}
|
||||
var factorial = params[0]
|
||||
var multiplier = params[0] - one
|
||||
//It is necessary to later prevent calls of factorial on anything but non-negative integers.
|
||||
while (multiplier.signum() == 1) {
|
||||
factorial *= multiplier
|
||||
multiplier -= one
|
||||
}
|
||||
return factorial
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,21 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* The multiplication operator.
|
||||
*
|
||||
* This is a standard operator that simply performs multiplication.
|
||||
*/
|
||||
class OperatorMultiply: NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 2) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params.size == 2
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params[0] * params[1]
|
||||
|
||||
}
|
|
@ -0,0 +1,26 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.plugin.standard.StandardPlugin.OP_FACTORIAL
|
||||
import org.nwapw.abacus.plugin.standard.StandardPlugin.OP_NPR
|
||||
|
||||
/**
|
||||
* The "N choose R" operator.
|
||||
*
|
||||
* This is a standard operator that returns the number of possible combinations, regardless of order,
|
||||
* of a certain size can be taken out of a pool of a bigger size.
|
||||
*/
|
||||
class OperatorNcr: NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 1) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params.size == 2 && params[0].isInteger()
|
||||
&& params[1].isInteger()
|
||||
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
OP_NPR.apply(context, *params) / OP_FACTORIAL.apply(context, params[1])
|
||||
|
||||
}
|
|
@ -0,0 +1,22 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* The negation operator.
|
||||
*
|
||||
* This is a standard operator that negates a number.
|
||||
*/
|
||||
class OperatorNegate: NumberOperator(OperatorAssociativity.LEFT, OperatorType.UNARY_PREFIX, 1) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params.size == 1
|
||||
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
-params[0]
|
||||
|
||||
}
|
|
@ -0,0 +1,42 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* The "N pick R" operator.
|
||||
*
|
||||
* his is a standard operator that returns the number of possible combinations
|
||||
* of a certain size can be taken out of a pool of a bigger size.
|
||||
*/
|
||||
class OperatorNpr: NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 1) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params.size == 2 && params[0].isInteger()
|
||||
&& params[1].isInteger()
|
||||
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out NumberInterface>): NumberInterface {
|
||||
val implementation = context.inheritedNumberImplementation
|
||||
if (params[0] < params[1] ||
|
||||
params[0].signum() < 0 ||
|
||||
params[0].signum() == 0 && params[1].signum() != 0)
|
||||
return implementation.instanceForString("0")
|
||||
var total = implementation.instanceForString("1")
|
||||
var multiplyBy = params[0]
|
||||
var remainingMultiplications = params[1]
|
||||
val halfway = params[0] / implementation.instanceForString("2")
|
||||
if (remainingMultiplications > halfway) {
|
||||
remainingMultiplications = params[0] - remainingMultiplications
|
||||
}
|
||||
while (remainingMultiplications.signum() > 0) {
|
||||
total *= multiplyBy
|
||||
remainingMultiplications -= implementation.instanceForString("1")
|
||||
multiplyBy -= implementation.instanceForString("1")
|
||||
}
|
||||
return total
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,28 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.TreeValueOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
import org.nwapw.abacus.tree.nodes.VariableNode
|
||||
|
||||
/**
|
||||
* The set operator.
|
||||
*
|
||||
* This is a standard operator that assigns a value to a variable name.
|
||||
*/
|
||||
class OperatorSet: TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out TreeNode>) =
|
||||
params.size == 2 && params[0] is VariableNode
|
||||
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out TreeNode>): NumberInterface {
|
||||
val assignTo = (params[0] as VariableNode).variable
|
||||
val value = params[1].reduce(context)
|
||||
context.setVariable(assignTo, value)
|
||||
return value
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,21 @@
|
|||
package org.nwapw.abacus.plugin.standard.operator
|
||||
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext
|
||||
import org.nwapw.abacus.function.OperatorAssociativity
|
||||
import org.nwapw.abacus.function.OperatorType
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
|
||||
/**
|
||||
* The subtraction operator.
|
||||
*
|
||||
* This is a standard operator that performs subtraction.
|
||||
*/
|
||||
class OperatorSubtract: NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1) {
|
||||
|
||||
override fun matchesParams(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params.size == 2
|
||||
override fun applyInternal(context: PluginEvaluationContext, params: Array<out NumberInterface>) =
|
||||
params[0] - params[1]
|
||||
|
||||
}
|
|
@ -1,52 +0,0 @@
|
|||
package org.nwapw.abacus.tree
|
||||
|
||||
/**
|
||||
* A tree node that holds a function call.
|
||||
*
|
||||
* The function call node can hold any number of children, and passes the to the appropriate reducer,
|
||||
* but that is its sole purpose.
|
||||
*
|
||||
* @param function the function string.
|
||||
*/
|
||||
data class FunctionNode(val function: String) : TreeNode() {
|
||||
|
||||
/**
|
||||
* List of function parameters added to this node.
|
||||
*/
|
||||
val children: MutableList<TreeNode> = mutableListOf()
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T? {
|
||||
val children = Array<Any>(children.size, { children[it].reduce(reducer) ?: return null; })
|
||||
return reducer.reduceNode(this, *children)
|
||||
}
|
||||
|
||||
override fun toString(): String {
|
||||
val buffer = StringBuffer()
|
||||
buffer.append(function)
|
||||
buffer.append('(')
|
||||
for (i in 0 until children.size) {
|
||||
buffer.append(children[i].toString())
|
||||
buffer.append(if (i == children.size - 1) ")" else ",")
|
||||
}
|
||||
return buffer.toString()
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends a child to this node's list of children.
|
||||
*
|
||||
* @node the node to append.
|
||||
*/
|
||||
fun appendChild(node: TreeNode) {
|
||||
children.add(node)
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepends a child to this node's list of children.
|
||||
*
|
||||
* @node the node to prepend.
|
||||
*/
|
||||
fun prependChild(node: TreeNode) {
|
||||
children.add(0, node)
|
||||
}
|
||||
|
||||
}
|
|
@ -1,5 +1,7 @@
|
|||
package org.nwapw.abacus.tree
|
||||
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode
|
||||
|
||||
/**
|
||||
* Reducer interface that takes a tree and returns a single value.
|
||||
*
|
||||
|
@ -14,6 +16,6 @@ interface Reducer<out T> {
|
|||
* @param treeNode the tree node to reduce.
|
||||
* @param children the list of children, of type T.
|
||||
*/
|
||||
fun reduceNode(treeNode: TreeNode, vararg children: Any): T?
|
||||
fun reduceNode(treeNode: TreeNode, vararg children: Any): T
|
||||
|
||||
}
|
|
@ -1,10 +0,0 @@
|
|||
package org.nwapw.abacus.tree
|
||||
|
||||
/**
|
||||
* A tree node.
|
||||
*/
|
||||
abstract class TreeNode {
|
||||
|
||||
abstract fun <T : Any> reduce(reducer: Reducer<T>): T?
|
||||
|
||||
}
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.tree
|
||||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
/**
|
||||
* A tree node that holds a binary operation.
|
||||
|
@ -11,16 +11,10 @@ package org.nwapw.abacus.tree
|
|||
* @param left the left node.
|
||||
* @param right the right node.
|
||||
*/
|
||||
data class BinaryNode(val operation: String, val left: TreeNode? = null, val right: TreeNode?) : TreeNode() {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T? {
|
||||
val leftReduce = left?.reduce(reducer) ?: return null
|
||||
val rightReduce = right?.reduce(reducer) ?: return null
|
||||
return reducer.reduceNode(this, leftReduce, rightReduce)
|
||||
}
|
||||
abstract class BinaryNode(val operation: String, val left: TreeNode, val right: TreeNode) : TreeNode() {
|
||||
|
||||
override fun toString(): String {
|
||||
return "(" + (left?.toString() ?: "null") + operation + (right?.toString() ?: "null") + ")"
|
||||
return "(" + left.toString() + operation + right.toString() + ")"
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,25 @@
|
|||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
/**
|
||||
* Represents a more generic function call.
|
||||
*
|
||||
* This class does not specify how it should be reduced, allowing other classes
|
||||
* to extend this functionality.
|
||||
*
|
||||
* @param callTo the name of the things being called.
|
||||
* @param children the children of this node.
|
||||
*/
|
||||
abstract class CallNode(val callTo: String, val children: List<TreeNode>) : TreeNode() {
|
||||
|
||||
override fun toString(): String {
|
||||
val buffer = StringBuffer()
|
||||
buffer.append(callTo)
|
||||
buffer.append("(")
|
||||
for (i in 0 until children.size) {
|
||||
buffer.append(children[i].toString())
|
||||
buffer.append(if (i != children.size - 1) ", " else ")")
|
||||
}
|
||||
return buffer.toString()
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,24 @@
|
|||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
|
||||
/**
|
||||
* A binary operator node that reduces its children.
|
||||
*
|
||||
* NumberBinaryNode operates by simply reducing its children and
|
||||
* then using the result of that reduction to reduce itself.
|
||||
*
|
||||
* @param operation the operation this node performs.
|
||||
* @param left the left child of this node.
|
||||
* @param right the right child of this node.
|
||||
*/
|
||||
class NumberBinaryNode(operation: String, left: TreeNode, right: TreeNode)
|
||||
: BinaryNode(operation, left, right) {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T {
|
||||
val left = left.reduce(reducer)
|
||||
val right = right.reduce(reducer)
|
||||
return reducer.reduceNode(this, left, right)
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,20 @@
|
|||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
|
||||
/**
|
||||
* A tree node that holds a function call.
|
||||
*
|
||||
* The function call node can hold any number of children, and passes the to the appropriate reducer,
|
||||
* but that is its sole purpose.
|
||||
*
|
||||
* @param function the function string.
|
||||
*/
|
||||
class NumberFunctionNode(function: String, children: List<TreeNode>) : CallNode(function, children) {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T {
|
||||
val children = Array<Any>(children.size, { children[it].reduce(reducer) })
|
||||
return reducer.reduceNode(this, *children)
|
||||
}
|
||||
|
||||
}
|
|
@ -1,6 +1,6 @@
|
|||
package org.nwapw.abacus.tree
|
||||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
import org.nwapw.abacus.number.NumberInterface
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
|
||||
/**
|
||||
* A tree node that holds a single number value.
|
||||
|
@ -10,14 +10,14 @@ import org.nwapw.abacus.number.NumberInterface
|
|||
*
|
||||
* @number the number value of this node.
|
||||
*/
|
||||
data class NumberNode(val number: NumberInterface) : TreeNode() {
|
||||
class NumberNode(val number: String) : TreeNode() {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T? {
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T {
|
||||
return reducer.reduceNode(this)
|
||||
}
|
||||
|
||||
override fun toString(): String {
|
||||
return number.toString()
|
||||
return number
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,21 @@
|
|||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
|
||||
/**
|
||||
* A unary operator node that reduces its children.
|
||||
*
|
||||
* NumberUnaryNode operates by simply reducing its child,
|
||||
* and using the result of that reduction to reduce itself.
|
||||
* @param operation the operation this node performs.
|
||||
* @param child the child this node should be applied to.
|
||||
*/
|
||||
class NumberUnaryNode(operation: String, child: TreeNode)
|
||||
: UnaryNode(operation, child) {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T {
|
||||
val child = applyTo.reduce(reducer)
|
||||
return reducer.reduceNode(this, child)
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,12 @@
|
|||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
|
||||
/**
|
||||
* A tree node.
|
||||
*/
|
||||
abstract class TreeNode {
|
||||
|
||||
abstract fun <T : Any> reduce(reducer: Reducer<T>): T
|
||||
|
||||
}
|
|
@ -0,0 +1,23 @@
|
|||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
|
||||
/**
|
||||
* A tree node that represents a binary tree value operator.
|
||||
*
|
||||
*
|
||||
* The tree value operators operate on trees, and so this
|
||||
* node does not reduce its children. It is up to the implementation to handle
|
||||
* reduction.
|
||||
* @param operation the operation this node performs.
|
||||
* @param left the left child of this node.
|
||||
* @param right the right child of this node.
|
||||
*/
|
||||
class TreeValueBinaryNode(operation: String, left: TreeNode, right: TreeNode)
|
||||
: BinaryNode(operation, left, right) {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T {
|
||||
return reducer.reduceNode(this)
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,18 @@
|
|||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
|
||||
/**
|
||||
* A tree node that represents a tree value function call.
|
||||
*
|
||||
* This is in many ways similar to a simple FunctionNode, and the distinction
|
||||
* is mostly to help the reducer. Besides that, this class also does not
|
||||
* even attempt to reduce its children.
|
||||
*/
|
||||
class TreeValueFunctionNode(name: String, children: List<TreeNode>) : CallNode(name, children) {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T {
|
||||
return reducer.reduceNode(this)
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,21 @@
|
|||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
|
||||
/**
|
||||
* A tree node that represents a unary tree value operator.
|
||||
*
|
||||
* The tree value operators operate on trees, and so this
|
||||
* node does not reduce its children. It is up to the implementation to handle
|
||||
* reduction.
|
||||
* @param operation the operation this node performs.
|
||||
* @param child the node the operation should be applied to.
|
||||
*/
|
||||
class TreeValueUnaryNode(operation: String, child: TreeNode)
|
||||
: UnaryNode(operation, child) {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T {
|
||||
return reducer.reduceNode(this)
|
||||
}
|
||||
|
||||
}
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.tree
|
||||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
/**
|
||||
* A tree node that holds a unary operation.
|
||||
|
@ -9,15 +9,10 @@ package org.nwapw.abacus.tree
|
|||
* @param operation the operation applied to the given node.
|
||||
* @param applyTo the node to which the operation will be applied.
|
||||
*/
|
||||
data class UnaryNode(val operation: String, val applyTo: TreeNode? = null) : TreeNode() {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T? {
|
||||
val reducedChild = applyTo?.reduce(reducer) ?: return null
|
||||
return reducer.reduceNode(this, reducedChild)
|
||||
}
|
||||
abstract class UnaryNode(val operation: String, val applyTo: TreeNode) : TreeNode() {
|
||||
|
||||
override fun toString(): String {
|
||||
return "(" + (applyTo?.toString() ?: "null") + ")" + operation
|
||||
return "(" + applyTo.toString() + ")" + operation
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,23 @@
|
|||
package org.nwapw.abacus.tree.nodes
|
||||
|
||||
import org.nwapw.abacus.tree.Reducer
|
||||
|
||||
/**
|
||||
* A tree node that holds a placeholder variable.
|
||||
*
|
||||
* This node holds a variable string, and acts similarly to a number,
|
||||
* with the key difference of not actually holding a value at runtime.
|
||||
*
|
||||
* @param variable the actual variable name that this node represents.
|
||||
*/
|
||||
class VariableNode(val variable: String) : TreeNode() {
|
||||
|
||||
override fun <T : Any> reduce(reducer: Reducer<T>): T {
|
||||
return reducer.reduceNode(this)
|
||||
}
|
||||
|
||||
override fun toString(): String {
|
||||
return variable
|
||||
}
|
||||
|
||||
}
|
|
@ -5,34 +5,36 @@ import org.junit.BeforeClass;
|
|||
import org.junit.Test;
|
||||
import org.nwapw.abacus.Abacus;
|
||||
import org.nwapw.abacus.config.Configuration;
|
||||
import org.nwapw.abacus.exception.DomainException;
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
import org.nwapw.abacus.plugin.StandardPlugin;
|
||||
import org.nwapw.abacus.tree.TreeNode;
|
||||
import org.nwapw.abacus.plugin.standard.StandardPlugin;
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode;
|
||||
|
||||
public class CalculationTests {
|
||||
|
||||
private static Abacus abacus = new Abacus(new Configuration(0, "precise", new String[]{}));
|
||||
private static Abacus abacus = new Abacus(new Configuration( "precise", new String[]{}));
|
||||
|
||||
@BeforeClass
|
||||
public static void prepareTests() {
|
||||
abacus.getPluginManager().addInstantiated(new StandardPlugin(abacus.getPluginManager()));
|
||||
abacus.getPluginManager().load();
|
||||
abacus.reload();
|
||||
}
|
||||
|
||||
private void testOutput(String input, String parseOutput, String output) {
|
||||
TreeNode parsedTree = abacus.parseString(input);
|
||||
Assert.assertNotNull(parsedTree);
|
||||
Assert.assertEquals(parsedTree.toString(), parseOutput);
|
||||
NumberInterface result = abacus.evaluateTree(parsedTree);
|
||||
NumberInterface result = abacus.evaluateTree(parsedTree).getValue();
|
||||
Assert.assertNotNull(result);
|
||||
Assert.assertTrue(result.toString().startsWith(output));
|
||||
}
|
||||
|
||||
private void testEvalError(String input, String parseOutput) {
|
||||
private void testDomainException(String input, String parseOutput) {
|
||||
TreeNode parsedTree = abacus.parseString(input);
|
||||
Assert.assertNotNull(parsedTree);
|
||||
Assert.assertEquals(parsedTree.toString(), parseOutput);
|
||||
Assert.assertNull(abacus.evaluateTree(parsedTree));
|
||||
try {
|
||||
abacus.evaluateTree(parsedTree);
|
||||
Assert.fail("Function did not throw DomainException.");
|
||||
} catch (DomainException e){ }
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -73,7 +75,7 @@ public class CalculationTests {
|
|||
|
||||
@Test
|
||||
public void testLn() {
|
||||
testEvalError("ln(-1)", "ln((1)`)");
|
||||
testDomainException("ln(-1)", "ln((1)`)");
|
||||
testOutput("ln2", "ln(2)", "0.6931471805599453094172321214581765680755");
|
||||
}
|
||||
|
||||
|
@ -100,8 +102,8 @@ public class CalculationTests {
|
|||
testOutput("2^-1", "(2^(1)`)", "0.5");
|
||||
testOutput("2^50", "(2^50)", "112589990684262");
|
||||
testOutput("7^(-sqrt2*17)", "(7^((sqrt(2)*17))`)", "4.81354609155297814551845300063563");
|
||||
testEvalError("0^0", "(0^0)");
|
||||
testEvalError("(-13)^.9999", "((13)`^0.9999)");
|
||||
testDomainException("0^0", "(0^0)");
|
||||
testDomainException("(-13)^.9999", "((13)`^.9999)");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -3,7 +3,7 @@ package org.nwapw.abacus.tests;
|
|||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.nwapw.abacus.lexing.Lexer;
|
||||
import org.nwapw.abacus.lexing.pattern.Match;
|
||||
import org.nwapw.abacus.lexing.Match;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
|
|
|
@ -0,0 +1,95 @@
|
|||
package org.nwapw.abacus.tests;
|
||||
|
||||
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.number.promotion.PromotionFunction;
|
||||
import org.nwapw.abacus.number.range.NumberRange;
|
||||
import org.nwapw.abacus.number.standard.NaiveNumber;
|
||||
import org.nwapw.abacus.number.standard.PreciseNumber;
|
||||
import org.nwapw.abacus.plugin.standard.StandardPlugin;
|
||||
|
||||
public class RangeTests {
|
||||
|
||||
private static Abacus abacus = new Abacus(new Configuration( "precise", new String[]{}));
|
||||
private static PromotionFunction naivePromotion = i -> new NaiveNumber((i.toString()));
|
||||
private static PromotionFunction precisePromotion = i -> new PreciseNumber((i.toString()));
|
||||
|
||||
@BeforeClass
|
||||
public static void prepareTests() {
|
||||
abacus.getPluginManager().addInstantiated(new StandardPlugin(abacus.getPluginManager()));
|
||||
abacus.reload();
|
||||
}
|
||||
|
||||
public static NumberRange naiveRange(String bottom, String top) {
|
||||
return new NaiveNumber(bottom).rangeTo(new NaiveNumber(top)).with(abacus);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNaiveRange(){
|
||||
NumberRange range = naiveRange("0", "10");
|
||||
Assert.assertTrue(range.getStart().toString().startsWith("0"));
|
||||
Assert.assertTrue(range.getEndInclusive().toString().startsWith("10"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNaiveRangeBelow() {
|
||||
NumberRange range = naiveRange("0", "10");
|
||||
Assert.assertFalse(range.contains(new NaiveNumber("-10")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNaiveRangeAbove() {
|
||||
NumberRange range = naiveRange("0", "10");
|
||||
Assert.assertFalse(range.contains(new NaiveNumber("20")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNaiveRangeJustWithinBottom() {
|
||||
NumberRange range = naiveRange("0", "10");
|
||||
Assert.assertTrue(range.contains(new NaiveNumber("0")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNaiveRangeJustWithinTop() {
|
||||
NumberRange range = naiveRange("0", "10");
|
||||
Assert.assertTrue(range.contains(new NaiveNumber("10")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNaiveRangeWithin() {
|
||||
NumberRange range = naiveRange("0", "10");
|
||||
Assert.assertTrue(range.contains(new NaiveNumber("5")));
|
||||
}
|
||||
|
||||
public static void addTestPromotionPaths() {
|
||||
StandardPlugin.IMPLEMENTATION_NAIVE.getPromotionPaths().put("precise", precisePromotion);
|
||||
StandardPlugin.IMPLEMENTATION_PRECISE.getPromotionPaths().put("naive", naivePromotion);
|
||||
abacus.reload();
|
||||
}
|
||||
|
||||
public static void removeTestPromotionPaths() {
|
||||
StandardPlugin.IMPLEMENTATION_NAIVE.getPromotionPaths().remove("precise");
|
||||
StandardPlugin.IMPLEMENTATION_NAIVE.getPromotionPaths().remove("naive");
|
||||
abacus.reload();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPromotionWithin() {
|
||||
addTestPromotionPaths();
|
||||
NumberRange range = naiveRange("0", "10");
|
||||
Assert.assertTrue(range.contains(new PreciseNumber("5")));
|
||||
removeTestPromotionPaths();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPromotionOutside(){
|
||||
addTestPromotionPaths();
|
||||
NumberRange range = naiveRange("0","10");
|
||||
Assert.assertFalse(range.contains(new PreciseNumber("20")));
|
||||
removeTestPromotionPaths();
|
||||
}
|
||||
|
||||
}
|
|
@ -1,44 +1,69 @@
|
|||
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.function.Function;
|
||||
import org.nwapw.abacus.function.Operator;
|
||||
import org.nwapw.abacus.context.MutableEvaluationContext;
|
||||
import org.nwapw.abacus.context.PluginEvaluationContext;
|
||||
import org.nwapw.abacus.function.OperatorAssociativity;
|
||||
import org.nwapw.abacus.function.OperatorType;
|
||||
import org.nwapw.abacus.lexing.pattern.Match;
|
||||
import org.nwapw.abacus.function.interfaces.NumberFunction;
|
||||
import org.nwapw.abacus.function.interfaces.NumberOperator;
|
||||
import org.nwapw.abacus.lexing.Match;
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
import org.nwapw.abacus.parsing.LexerTokenizer;
|
||||
import org.nwapw.abacus.parsing.standard.LexerTokenizer;
|
||||
import org.nwapw.abacus.parsing.standard.TokenType;
|
||||
import org.nwapw.abacus.plugin.Plugin;
|
||||
import org.nwapw.abacus.tree.TokenType;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class TokenizerTests {
|
||||
|
||||
private static Abacus abacus = new Abacus(new Configuration(0, "precise", new String[]{}));
|
||||
private static Abacus abacus = new Abacus(new Configuration("precise", new String[]{}));
|
||||
private static LexerTokenizer lexerTokenizer = new LexerTokenizer();
|
||||
private static Function subtractFunction = new Function() {
|
||||
private static NumberFunction subtractFunction = new NumberFunction() {
|
||||
@Override
|
||||
protected boolean matchesParams(NumberInterface[] params) {
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params.length == 2;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected NumberInterface applyInternal(NumberInterface[] params) {
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return params[0].subtract(params[1]);
|
||||
}
|
||||
};
|
||||
private static Plugin testPlugin = new Plugin(abacus.getPluginManager()) {
|
||||
@Override
|
||||
public void onEnable() {
|
||||
registerOperator("+", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
|
||||
0, subtractFunction));
|
||||
registerOperator("-", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
|
||||
0, subtractFunction));
|
||||
registerOperator("+", new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
|
||||
0) {
|
||||
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return subtractFunction.apply(context, params);
|
||||
}
|
||||
});
|
||||
registerOperator("-", new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
|
||||
0) {
|
||||
|
||||
@Override
|
||||
public boolean matchesParams(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NumberInterface applyInternal(PluginEvaluationContext context, NumberInterface[] params) {
|
||||
return subtractFunction.apply(context, params);
|
||||
}
|
||||
});
|
||||
registerFunction("subtract", subtractFunction);
|
||||
}
|
||||
|
||||
|
@ -60,7 +85,7 @@ public class TokenizerTests {
|
|||
public static void prepareTests() {
|
||||
abacus.getPluginManager().addListener(lexerTokenizer);
|
||||
abacus.getPluginManager().addInstantiated(testPlugin);
|
||||
abacus.getPluginManager().load();
|
||||
abacus.reload();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
|
@ -3,7 +3,8 @@
|
|||
{% include head.html %}
|
||||
<style>
|
||||
body {
|
||||
margin-top: 100px;
|
||||
margin: 0px;
|
||||
margin-top: 50px;
|
||||
color: white;
|
||||
text-align: center;
|
||||
}
|
||||
|
@ -11,7 +12,13 @@
|
|||
font-family: "Source Code Pro"
|
||||
}
|
||||
|
||||
img {
|
||||
img#logo {
|
||||
margin: auto;
|
||||
width: 100%;
|
||||
max-width: 100px;
|
||||
}
|
||||
|
||||
img#image_preview {
|
||||
margin: auto;
|
||||
width: 100%;
|
||||
max-width: 432px;
|
||||
|
@ -31,8 +38,61 @@
|
|||
background-color: #06e8a4;
|
||||
color: white;
|
||||
}
|
||||
|
||||
div.fullwidth {
|
||||
width: 100%;
|
||||
height: auto;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
div.fullwidth img {
|
||||
max-width: 100%;
|
||||
max-height: 450px;
|
||||
margin: auto;
|
||||
margin-top: 20px;
|
||||
margin-bottom: 20px;
|
||||
display: block;
|
||||
border-radius: 5px;
|
||||
}
|
||||
|
||||
div.white {
|
||||
background-color: white;
|
||||
color: black;
|
||||
}
|
||||
|
||||
div.green {
|
||||
background-color: #06e8a4;
|
||||
color: white;
|
||||
}
|
||||
|
||||
div.fullwidth div.double {
|
||||
height: 100%;
|
||||
text-align: left;
|
||||
width: 50%;
|
||||
box-sizing: border-box;
|
||||
padding: 40px;
|
||||
float: left;
|
||||
background-color: inherit;
|
||||
}
|
||||
|
||||
@media (max-width: 750px) {
|
||||
div.fullwidth div.double {
|
||||
width: 100%;
|
||||
padding: 15px;
|
||||
}
|
||||
div.fullwidth img {
|
||||
margin-top: 0px;
|
||||
margin-bottom: 0px;
|
||||
}
|
||||
}
|
||||
|
||||
div.fullwidth div.double h1, h2, h3, h4, h5, h6 {
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
</style>
|
||||
<body>
|
||||
<img src="https://raw.githubusercontent.com/DanilaFe/abacus/master/image/logo.png" id="logo">
|
||||
<h1>Abacus</h1>
|
||||
<h2>The programmer's calculator</h2>
|
||||
<div id="buttons">
|
||||
|
@ -41,6 +101,59 @@
|
|||
<a class="button inverted" href="https://github.com/DanilaFe/abacus">Contribute</a>
|
||||
<a class="button inverted" href="https://github.com/DanilaFe/abacus/wiki">Wiki</a>
|
||||
</div>
|
||||
<img src="http://i.imgur.com/Min70QY.png" title="source: imgur.com" />
|
||||
<img src="http://i.imgur.com/Min70QY.png" title="source: imgur.com" id="image_preview"/>
|
||||
<h2>Features</h2>
|
||||
<div class="fullwidth white">
|
||||
<div class="double">
|
||||
<img src="https://i.imgur.com/gmGJBBK.png">
|
||||
</div>
|
||||
<div class="double">
|
||||
<h2>Precision</h2>
|
||||
Abacus uses a mathematical tool called Taylor Series to determine values
|
||||
as accurate as the user desires. Of course, this comes with some
|
||||
performance issues with larger numbers. However, Abacus has been
|
||||
tested to generate the value of e correctly to a thousand digits.
|
||||
</div>
|
||||
</div>
|
||||
<div class="fullwidth green">
|
||||
<div class="double">
|
||||
<h2>Configurable and Customizable</h2>
|
||||
The very first idea for Abacus was inspired by how difficult it was
|
||||
to program a TI-84 calculator. Only two languages were available, TI-BASIC
|
||||
and Assembly, the latter having virtually no documentation. Determined
|
||||
to be better than a TI-84, Abacus implemented a plugin system that allows
|
||||
users to easily create and add plugins written in the same programming
|
||||
language as Abacus itself - Java. These plugins can access the full
|
||||
power of the language, and implement their own ways of handling numbers,
|
||||
as well as their own functions and even operators.<br><br>
|
||||
Besides the ability to add plugins, Abacus also adds some general
|
||||
options that can be used to make the user's experience more pleasant.
|
||||
For instance, it allows for a computation limit to be set in order
|
||||
to prevent excessively long evaluation: 8!!! is, for example, an expression
|
||||
that even Wolfram Alpha doesn't compute accurately, and will never finish
|
||||
on Abacus (it's simply too large). The computation limit will allow Abacus
|
||||
to kill a computation if it takes too long. Support for user-definable
|
||||
precision is also planned.
|
||||
</div>
|
||||
<div class="double">
|
||||
<img src="https://i.imgur.com/JzenWPV.png">
|
||||
</div>
|
||||
</div>
|
||||
<div class="fullwidth white">
|
||||
<div class="double">
|
||||
<img src="https://i.imgur.com/jY17I3A.png">
|
||||
</div>
|
||||
<div class="double">
|
||||
<h2>Built-in Documentation</h2>
|
||||
Abacus plugins are given a mechanism to register documentation for
|
||||
the functions that they provide. The Abacus GUI displays these
|
||||
functions in a searchable list, allowing the user to read the parameters
|
||||
that have to be supplied to each function, as well as learn about
|
||||
its return value.<br><br>
|
||||
The search finds functions not only by their names, but also by relevant
|
||||
terms mentioned in the function's description, thus allowing related
|
||||
functions to be displayed together.
|
||||
</div>
|
||||
</div>
|
||||
</body>
|
||||
</html>
|
||||
|
|
|
@ -7,7 +7,7 @@ $code-color: #efefef;
|
|||
$accent-color: #00AFE8;
|
||||
$clear-color: white;
|
||||
$title-font: "Open Sans";
|
||||
$text-font: Helvetica;
|
||||
$text-font: "Raleway";
|
||||
$code-font: "Source Code Pro";
|
||||
$max-width: 850px;
|
||||
|
||||
|
|
|
@ -1,9 +1,7 @@
|
|||
plugins {
|
||||
id 'org.jetbrains.kotlin.jvm' version '1.1.3'
|
||||
}
|
||||
apply plugin: 'application'
|
||||
|
||||
dependencies {
|
||||
compile 'com.moandjiezana.toml:toml4j:0.7.2'
|
||||
compile project(':core')
|
||||
}
|
||||
|
||||
|
|
|
@ -26,7 +26,7 @@ public class AbacusApplication extends Application {
|
|||
FXMLLoader loader = new FXMLLoader(getClass().getResource("/abacus.fxml"));
|
||||
Parent parent = loader.load();
|
||||
controller = loader.getController();
|
||||
Scene mainScene = new Scene(parent, 320, 480);
|
||||
Scene mainScene = new Scene(parent, 420, 520);
|
||||
primaryStage.setScene(mainScene);
|
||||
primaryStage.setTitle("Abacus");
|
||||
primaryStage.show();
|
||||
|
|
|
@ -8,24 +8,28 @@ import javafx.fxml.FXML;
|
|||
import javafx.scene.control.*;
|
||||
import javafx.scene.control.cell.CheckBoxListCell;
|
||||
import javafx.scene.text.Text;
|
||||
import javafx.stage.FileChooser;
|
||||
import javafx.util.Callback;
|
||||
import javafx.util.StringConverter;
|
||||
import org.nwapw.abacus.Abacus;
|
||||
import org.nwapw.abacus.config.Configuration;
|
||||
import org.nwapw.abacus.exception.AbacusException;
|
||||
import org.nwapw.abacus.function.Documentation;
|
||||
import org.nwapw.abacus.function.DocumentationType;
|
||||
import org.nwapw.abacus.number.ComputationInterruptedException;
|
||||
import org.nwapw.abacus.number.NumberInterface;
|
||||
import org.nwapw.abacus.plugin.ClassFinder;
|
||||
import org.nwapw.abacus.number.*;
|
||||
import org.nwapw.abacus.plugin.PluginListener;
|
||||
import org.nwapw.abacus.plugin.PluginManager;
|
||||
import org.nwapw.abacus.plugin.StandardPlugin;
|
||||
import org.nwapw.abacus.tree.TreeNode;
|
||||
import org.nwapw.abacus.plugin.standard.StandardPlugin;
|
||||
import org.nwapw.abacus.EvaluationResult;
|
||||
import org.nwapw.abacus.tree.nodes.TreeNode;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.FileReader;
|
||||
import java.io.IOException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
import java.util.Scanner;
|
||||
import java.util.Set;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
|
@ -69,6 +73,7 @@ public class AbacusController implements PluginListener {
|
|||
* Constant string that is displayed if the calculations are interrupted by an exception.
|
||||
*/
|
||||
private static final String ERR_EXCEPTION = "Exception Thrown";
|
||||
private static final String ERR_DEFINITION = "Definition Error";
|
||||
@FXML
|
||||
private TabPane coreTabPane;
|
||||
@FXML
|
||||
|
@ -103,6 +108,8 @@ public class AbacusController implements PluginListener {
|
|||
private ListView<Documentation> functionListView;
|
||||
@FXML
|
||||
private TextField functionListSearchField;
|
||||
@FXML
|
||||
private ListView<String> definitionFilesView;
|
||||
|
||||
/**
|
||||
* The list of history entries, created by the users.
|
||||
|
@ -128,6 +135,10 @@ public class AbacusController implements PluginListener {
|
|||
* The filtered list displayed to the user.
|
||||
*/
|
||||
private FilteredList<Documentation> functionFilter;
|
||||
/**
|
||||
* The list of definition files to be loaded.
|
||||
*/
|
||||
private ObservableList<String> definitionFiles;
|
||||
|
||||
/**
|
||||
* The abacus instance used for changing the plugin configuration.
|
||||
|
@ -141,18 +152,14 @@ public class AbacusController implements PluginListener {
|
|||
private String attemptCalculation() {
|
||||
try {
|
||||
TreeNode constructedTree = abacus.parseString(inputField.getText());
|
||||
if (constructedTree == null) {
|
||||
return ERR_SYNTAX;
|
||||
}
|
||||
NumberInterface evaluatedNumber = abacus.evaluateTree(constructedTree);
|
||||
if (evaluatedNumber == null) {
|
||||
return ERR_EVAL;
|
||||
}
|
||||
EvaluationResult result = abacus.evaluateTree(constructedTree);
|
||||
NumberInterface evaluatedNumber = result.getValue();
|
||||
String resultingString = evaluatedNumber.toString();
|
||||
historyData.add(new HistoryModel(inputField.getText(), constructedTree.toString(), resultingString));
|
||||
abacus.applyToContext(result.getResultingContext());
|
||||
return resultingString;
|
||||
} catch (ComputationInterruptedException exception) {
|
||||
return ERR_STOP;
|
||||
} catch (AbacusException exception) {
|
||||
return exception.getMessage();
|
||||
} catch (RuntimeException exception) {
|
||||
exception.printStackTrace();
|
||||
return ERR_EXCEPTION;
|
||||
|
@ -195,7 +202,7 @@ public class AbacusController implements PluginListener {
|
|||
*/
|
||||
private final Runnable TIMER_RUNNABLE = () -> {
|
||||
try {
|
||||
Configuration abacusConfig = abacus.getConfiguration();
|
||||
ExtendedConfiguration abacusConfig = (ExtendedConfiguration) abacus.getConfiguration();
|
||||
if (abacusConfig.getComputationDelay() == 0) return;
|
||||
Thread.sleep((long) (abacusConfig.getComputationDelay() * 1000));
|
||||
performStop();
|
||||
|
@ -255,12 +262,15 @@ public class AbacusController implements PluginListener {
|
|||
if (oldValue.equals(settingsTab)) alertIfApplyNeeded(true);
|
||||
});
|
||||
|
||||
abacus = new Abacus(new Configuration(CONFIG_FILE));
|
||||
definitionFiles = FXCollections.observableArrayList();
|
||||
definitionFilesView.setItems(definitionFiles);
|
||||
|
||||
abacus = new Abacus(new ExtendedConfiguration(CONFIG_FILE));
|
||||
PluginManager abacusPluginManager = abacus.getPluginManager();
|
||||
abacusPluginManager.addListener(this);
|
||||
performScan();
|
||||
|
||||
computationLimitField.setText(Double.toString(abacus.getConfiguration().getComputationDelay()));
|
||||
computationLimitField.setText(Double.toString(((ExtendedConfiguration) abacus.getConfiguration()).getComputationDelay()));
|
||||
computationLimitField.textProperty().addListener((observable, oldValue, newValue) -> {
|
||||
if (!newValue.matches("(\\d+(\\.\\d*)?)?")) {
|
||||
computationLimitField.setText(oldValue);
|
||||
|
@ -308,6 +318,25 @@ public class AbacusController implements PluginListener {
|
|||
reloadAlertShown = false;
|
||||
}
|
||||
|
||||
private void loadDefinitionFile(String fileName){
|
||||
File definitionFile = new File(fileName);
|
||||
if(!definitionFile.exists()) return;
|
||||
try {
|
||||
FileReader fileReader = new FileReader(definitionFile);
|
||||
Scanner scanner = new Scanner(fileReader);
|
||||
while(scanner.hasNext()){
|
||||
EvaluationResult result = abacus.evaluateTree(abacus.parseString(scanner.nextLine()));
|
||||
abacus.applyToContext(result.getResultingContext());
|
||||
}
|
||||
} catch (AbacusException abacusError) {
|
||||
outputText.setText(ERR_DEFINITION + " (" + abacusError.getMessage() + ")");
|
||||
abacusError.printStackTrace();
|
||||
} catch (RuntimeException runtime) {
|
||||
outputText.setText(ERR_DEFINITION + " (" + ERR_EXCEPTION + ")");
|
||||
runtime.printStackTrace();
|
||||
} catch (FileNotFoundException ignored) {}
|
||||
}
|
||||
|
||||
@FXML
|
||||
public void performScan() {
|
||||
PluginManager abacusPluginManager = abacus.getPluginManager();
|
||||
|
@ -318,24 +347,27 @@ public class AbacusController implements PluginListener {
|
|||
} catch (IOException | ClassNotFoundException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
abacusPluginManager.reload();
|
||||
reloadAbacus();
|
||||
}
|
||||
|
||||
@FXML
|
||||
public void performReload() {
|
||||
alertIfApplyNeeded(true);
|
||||
abacus.getPluginManager().reload();
|
||||
reloadAbacus();
|
||||
}
|
||||
|
||||
@FXML
|
||||
public void performSave() {
|
||||
Configuration configuration = abacus.getConfiguration();
|
||||
ExtendedConfiguration configuration = (ExtendedConfiguration) abacus.getConfiguration();
|
||||
configuration.setNumberImplementation(numberImplementationBox.getSelectionModel().getSelectedItem());
|
||||
Set<String> disabledPlugins = configuration.getDisabledPlugins();
|
||||
disabledPlugins.clear();
|
||||
for (ToggleablePlugin pluginEntry : enabledPlugins) {
|
||||
if (!pluginEntry.isEnabled()) disabledPlugins.add(pluginEntry.getClassName());
|
||||
}
|
||||
Set<String> abacusDefinitionFiles = configuration.getDefinitionFiles();
|
||||
abacusDefinitionFiles.clear();
|
||||
abacusDefinitionFiles.addAll(definitionFiles);
|
||||
if (computationLimitField.getText().matches("\\d*(\\.\\d+)?") && computationLimitField.getText().length() != 0)
|
||||
configuration.setComputationDelay(Double.parseDouble(computationLimitField.getText()));
|
||||
configuration.saveTo(CONFIG_FILE);
|
||||
|
@ -343,9 +375,34 @@ public class AbacusController implements PluginListener {
|
|||
reloadAlertShown = false;
|
||||
}
|
||||
|
||||
@FXML
|
||||
public void performAddDefinitionFile(){
|
||||
FileChooser fileChooser = new FileChooser();
|
||||
fileChooser.setTitle("Add definition file");
|
||||
File selectedFile = fileChooser.showOpenDialog(null);
|
||||
if(selectedFile == null) return;
|
||||
String absolutePath = selectedFile.getAbsolutePath();
|
||||
if(!definitionFiles.contains(absolutePath)) definitionFiles.add(absolutePath);
|
||||
changesMade = true;
|
||||
}
|
||||
|
||||
@FXML
|
||||
public void performRemoveDefinitionFile(){
|
||||
String selectedItem = definitionFilesView.getSelectionModel().getSelectedItem();
|
||||
if(selectedItem != null) definitionFiles.remove(selectedItem);
|
||||
changesMade = true;
|
||||
}
|
||||
|
||||
private void reloadAbacus(){
|
||||
abacus.reload();
|
||||
for(String file : definitionFiles){
|
||||
loadDefinitionFile(file);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onLoad(PluginManager manager) {
|
||||
Configuration configuration = abacus.getConfiguration();
|
||||
ExtendedConfiguration configuration = (ExtendedConfiguration) abacus.getConfiguration();
|
||||
Set<String> disabledPlugins = configuration.getDisabledPlugins();
|
||||
numberImplementationOptions.addAll(abacus.getPluginManager().getAllNumberImplementations());
|
||||
String actualImplementation = configuration.getNumberImplementation();
|
||||
|
@ -358,9 +415,20 @@ public class AbacusController implements PluginListener {
|
|||
enabledPlugins.add(plugin);
|
||||
}
|
||||
PluginManager pluginManager = abacus.getPluginManager();
|
||||
functionList.addAll(manager.getAllFunctions().stream().map(name -> pluginManager.documentationFor(name, DocumentationType.FUNCTION))
|
||||
.collect(Collectors.toCollection(ArrayList::new)));
|
||||
functionList.addAll(manager.getAllFunctions().stream().map(name -> {
|
||||
Documentation documentationInstance = pluginManager.documentationFor(name, DocumentationType.FUNCTION);
|
||||
if(documentationInstance == null)
|
||||
documentationInstance = new Documentation(name, "", "", "", DocumentationType.FUNCTION);
|
||||
return documentationInstance;
|
||||
}).collect(Collectors.toCollection(ArrayList::new)));
|
||||
functionList.addAll(manager.getAllTreeValueFunctions().stream().map(name -> {
|
||||
Documentation documentationInstance = pluginManager.documentationFor(name, DocumentationType.TREE_VALUE_FUNCTION);
|
||||
if(documentationInstance == null)
|
||||
documentationInstance = new Documentation(name, "", "", "", DocumentationType.TREE_VALUE_FUNCTION);
|
||||
return documentationInstance;
|
||||
}).collect(Collectors.toCollection(ArrayList::new)));
|
||||
functionList.sort(Comparator.comparing(Documentation::getCodeName));
|
||||
definitionFiles.addAll(configuration.getDefinitionFiles());
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -368,6 +436,7 @@ public class AbacusController implements PluginListener {
|
|||
functionList.clear();
|
||||
enabledPlugins.clear();
|
||||
numberImplementationOptions.clear();
|
||||
definitionFiles.clear();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
package org.nwapw.abacus.plugin;
|
||||
package org.nwapw.abacus.fx;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue