Fix a bug that made some same-priority implementations not convert.

Add an exception thrown when promotion fails.

.gitignore

@@ -24,7 +24,9 @@ hs_err_pid*
 # Custom Stuff
 # Gradle
 .gradle/*
-build/*
+**/build/*
+**/out/**
+**/.DS_Store
 
 # IntelliJ
 .idea/*

core/src/main/java/org/nwapw/abacus/exception/PromotionException.java

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

core/src/main/java/org/nwapw/abacus/number/NumberInterface.java

@@ -5,7 +5,7 @@ import org.nwapw.abacus.exception.ComputationInterruptedException;
 /**
  * An interface used to represent a number.
  */
-public abstract class NumberInterface {
+public abstract class NumberInterface implements Comparable<NumberInterface> {
 
     /**
      * Check if the thread was interrupted and
@@ -158,14 +158,6 @@ public abstract class NumberInterface {
         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().
      *

core/src/main/kotlin/org/nwapw/abacus/Abacus.kt

@@ -68,6 +68,7 @@ class Abacus(val configuration: Configuration) {
         pluginManager.reload()
         with(mutableContext) {
             numberImplementation = pluginManager.numberImplementationFor(configuration.numberImplementation)
+                    ?: StandardPlugin.IMPLEMENTATION_NAIVE
             clearVariables()
             clearDefinitions()
         }

core/src/main/kotlin/org/nwapw/abacus/number/PromotionManager.kt

@@ -1,6 +1,7 @@
 package org.nwapw.abacus.number
 
 import org.nwapw.abacus.Abacus
+import org.nwapw.abacus.exception.PromotionException
 import org.nwapw.abacus.plugin.NumberImplementation
 import org.nwapw.abacus.plugin.PluginListener
 import org.nwapw.abacus.plugin.PluginManager
@@ -45,27 +46,25 @@ class PromotionManager(val abacus: Abacus) : PluginListener {
      * @param numbers the numbers to promote.
      * @return the resulting promotion result.
      */
-    fun promote(vararg numbers: NumberInterface): PromotionResult? {
+    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) ?: return null
+                    ?.promote(it) ?: throw PromotionException()
         }.toTypedArray(), promotedTo = highestPriority)
     }
 
     override fun onLoad(manager: PluginManager) {
         val implementations = manager.allNumberImplementations.map { manager.numberImplementationFor(it) }
-        for((index, value) in implementations.withIndex()){
-            for(i in index until implementations.size){
-                val other = implementations[i]
-
-                val promoteFrom = if(other.priority > value.priority) value else other
-                val promoteTo = if(other.priority > value.priority) other else value
+        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.put(promoteFrom to promoteTo, path)
+                computePaths[promoteFrom to promoteTo] = path
             }
         }
     }

core/src/main/kotlin/org/nwapw/abacus/tree/NumberReducer.kt

@@ -36,15 +36,13 @@ class NumberReducer(val abacus: Abacus, context: EvaluationContext) : Reducer<Nu
             is NumberBinaryNode -> {
                 val left = children[0] as NumberInterface
                 val right = children[1] as NumberInterface
-                val promotionResult = promotionManager.promote(left, right) ?:
-                        throw EvaluationException("promotion failed.")
+                val promotionResult = promotionManager.promote(left, right)
                 context.numberImplementation = promotionResult.promotedTo
                 abacus.pluginManager.operatorFor(treeNode.operation).apply(context, *promotionResult.items)
             }
             is FunctionNode -> {
                 val promotionResult = promotionManager
-                        .promote(*children.map { it as NumberInterface }.toTypedArray()) ?:
-                        throw EvaluationException("promotion failed.")
+                        .promote(*children.map { it as NumberInterface }.toTypedArray())
                 context.numberImplementation = promotionResult.promotedTo
                 abacus.pluginManager.functionFor(treeNode.callTo).apply(context, *promotionResult.items)
             }