fixed final bugs for release

Author: Tran-Antoine

Diff for: src/main/java/net/akami/mask/operation/Derivative.java

@@ -9,6 +9,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+/**
+ * Does not work yet
+ */
 public class Derivative {
 
     private static final Derivative INSTANCE = new Derivative();

Diff for: src/main/java/net/akami/mask/operation/Sum.java

@@ -9,7 +9,6 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.regex.Pattern;
 
 public class Sum extends BinaryOperationHandler {
 
@@ -90,7 +89,7 @@ public String monomialSum(List<String> monomials, boolean needsFormatting) {
             if (rest.startsWith("+") || rest.startsWith("-")) {
                 BUILDER.append(rest);
             } else {
-                BUILDER.append("+" + rest);
+                BUILDER.append('+').append(rest);
             }
         }
         String result = BUILDER.toString();
@@ -145,12 +144,6 @@ private void fillMonomialList(String monomial, int i, List<String> initialMonomi
      * 2x + 2x + 3x
      * -> Compatible unknown part : x. Hence, initialMonomial is 2x, others contains 2x and 3x, it removes
      * the three monomials to the initial list, and adds 7x to the final list
-     * @param initialMonomial
-     * @param vars
-     * @param index
-     * @param others
-     * @param initialMonomials
-     * @param finalMonomials
      */
     private void replaceMonomialsByResult(String initialMonomial, String vars, int index, Map<BigDecimal, Integer> others,
                                           List<String> initialMonomials, List<String> finalMonomials) {

Diff for: src/main/java/net/akami/mask/utils/ExpressionUtils.java

@@ -16,7 +16,7 @@ public class ExpressionUtils {
     private static final String DELETE_NON_VARIABLES = "[\\d.+\\-/*()^]+";
     public static final String MATH_SIGNS = "+-*/^()";
     public static final String NUMBERS = "0123456789";
-    // 'E' deliberately missing
+    // 'E' deliberately missing, because it corresponds to "*10^x"
     public static final String VARIABLES = "abcdefghijklmnopqrstuvwxyzABCDFGHIJKLMNOPQRSTUVWXYZ";
     public static final String TRIGONOMETRY_SHORTCUTS = "@#§";
     public static List<String> toMonomials(String self) {
@@ -50,84 +50,6 @@ public static List<String> toMonomials(String self) {
         return monomials;
     }
 
-    public static String toVariablesUnused(String exp) {
-
-        String[] unSortedVars = keepEachCharacterOnce(exp.replaceAll(DELETE_NON_VARIABLES, "")).split("");
-        if (unSortedVars.length == 0)
-            return "";
-
-        Arrays.sort(unSortedVars);
-        String vars = String.join("", unSortedVars);
-
-        LOGGER.debug("Looking for the variables of the sequence : {}", exp);
-        List<String> finalVars = new ArrayList<>();
-        StringBuilder builtExpression = new StringBuilder();
-        builtExpression.append(exp);
-        clearBuilder();
-        // Going through the variables
-        for (int i = 0; i < vars.length(); i++) {
-            int partsAmount = 0;
-            char var = vars.charAt(i);
-
-            LOGGER.debug("Treating {}", var);
-
-            // can happen if 'x^y', the y has been transformed to '$', meaning it wasn't a variable but an sequence.
-            if (!builtExpression.toString().contains(String.valueOf(var))) {
-                LOGGER.debug("Variable {} not found. Skipping.", var);
-                continue;
-            }
-
-            for (int j = 0; j < builtExpression.length(); j++) {
-
-                char c1 = builtExpression.charAt(j);
-                // The treated variable has been found
-                if (var == c1) {
-                    partsAmount++;
-                    LOGGER.debug("Identical variable found at index {} : {}", j, c1);
-                    // If now powers after the variable
-                    if (j + 2 > builtExpression.length() || builtExpression.charAt(j + 1) != '^') {
-                        BUILDER.append("+1");
-                        LOGGER.debug("No power found. Adds 1");
-                    } else {
-                        SequenceCalculationResult sequenceResult = groupAfter(j + 1, exp);
-                        String exponent = sequenceResult.sequence;
-                        String valuelessSequence = exponent.replaceAll(".", "\\$");
-                        builtExpression.replace(sequenceResult.start, sequenceResult.end, valuelessSequence);
-                        BUILDER.append("+").append(exponent);
-                        LOGGER.debug("Power found. Adds {}", exponent);
-                    }
-                    builtExpression.setCharAt(j, '$');
-                    LOGGER.debug("Sequence : {}", builtExpression.toString());
-                    LOGGER.debug("Exponent : {}", BUILDER.toString());
-                }
-            }
-            if (BUILDER.charAt(0) == '+')
-                BUILDER.deleteCharAt(0);
-
-            if (partsAmount > 1) {
-                LOGGER.debug("Several parts forming the power : {}. Needs extra monomialSum", BUILDER.toString());
-                String reducedExponent = MathUtils.sum(BUILDER.toString(), "");
-                clearBuilder();
-                BUILDER.append(reducedExponent);
-            }
-            String exponent = BUILDER.toString();
-            if (!isReduced(exponent)) {
-                exponent = "(" + exponent + ")";
-            }
-            LOGGER.debug("Final sequence calculation of {} : {}", var, exponent);
-            if (exponent.equals("1")) {
-                finalVars.add(String.valueOf(var));
-            } else {
-                finalVars.add(var + "^" + exponent);
-            }
-            clearBuilder();
-        }
-        String result = String.join("", finalVars);
-
-        LOGGER.debug("Result of toVariables(): {}", result);
-        return result;
-    }
-
     public static String toVariables(String exp) {
         Pattern pattern = Pattern.compile("(([a-zA-DF-Z]\\^(\\(.+\\)|([0-9.]+)|[a-zA-DF-Z]))|[a-zA-DF-Z])+");
         Matcher matcher = pattern.matcher(exp);
@@ -232,34 +154,6 @@ public static SequenceCalculationResult groupAfter(int index, String exp) {
         LOGGER.debug("Result of group at index {} for {} : {}", index, exp, result.sequence);
         return result;
     }
-    public static SequenceCalculationResult groupBefore(int index, String exp) {
-        if(index > 0 && exp.charAt(index-1) == ')') {
-            return bracketSequenceBefore(index, exp);
-        }
-        LOGGER.debug("No bracket sequence after char at index {}", index);
-        SequenceCalculationResult result = new SequenceCalculationResult();
-        for (int i = index - 1; i >= 0; i--) {
-            char c = exp.charAt(i);
-
-            if ("+-*/^".contains(String.valueOf(c))) {
-                LOGGER.debug("Found an operator : {} at index {}. Stopped", c, i);
-                result.sequence = exp.substring(i, index);
-                result.start = i;
-                result.end = index;
-                break;
-            }
-
-            if(i == 0) {
-                LOGGER.debug("Reached the end of the string.");
-                result.sequence = exp.substring(0, index);
-                result.start = 0;
-                result.end = index;
-            }
-        }
-        removeBrackets(result, exp, index, false);
-        LOGGER.debug("Result of group at index {} for {} : {}", index, exp, result.sequence);
-        return result;
-    }
 
     public static SequenceCalculationResult bracketSequenceAfter(int index, String exp) {
 
@@ -290,46 +184,6 @@ public static SequenceCalculationResult bracketSequenceAfter(int index, String e
         return result;
     }
 
-    public static SequenceCalculationResult bracketSequenceBefore(int index, String exp) {
-        SequenceCalculationResult result = new SequenceCalculationResult();
-
-        int closingBrackets = 0;
-        for (int i = index - 1; i >= 0; i--) {
-            char c = exp.charAt(i);
-
-            if (c == '(') {
-                if(closingBrackets <= 0) {
-                    LOGGER.debug("Found the closing bracket");
-                    result.start = i+1;
-                    result.sequence = exp.substring(i+1, index-1);
-                    result.end = index-1;
-                    break;
-                } else {
-                    closingBrackets--;
-                }
-            }
-            if(c == ')' && i != index+1) {
-                closingBrackets++;
-            }
-        }
-
-        //removeBrackets(result, exp, index, false);
-        LOGGER.debug("Sequence {} after pow at index {} found : {}", exp, index, result.sequence);
-        return result;
-    }
-
-    private static void removeBrackets(SequenceCalculationResult result, String exp, int index, boolean leftToR) {
-        if (result.sequence == null) {
-            LOGGER.debug("Sequence null");
-            result.sequence = leftToR ? exp.substring(index + 1) : exp.substring(0, index);
-            result.start = leftToR ? index : 0;
-            result.end = leftToR ? exp.length() : index;
-        }
-        while(areEdgesBracketsConnected(result.sequence)) {
-            result.sequence = result.sequence.substring(1, result.sequence.length()-1);
-        }
-    }
-
     public static String keepEachCharacterOnce(String self) {
         List<String> chars = new ArrayList<>();
         for (char c : self.toCharArray()) {

Diff for: src/main/java/net/akami/mask/utils/FormatterFactory.java

@@ -7,7 +7,6 @@
 
 public class FormatterFactory {
 
-    private static final StringBuilder BUILDER = new StringBuilder();
     private static final Logger LOGGER = LoggerFactory.getLogger(FormatterFactory.class);
 
     public static String removeFractions(String origin) {
@@ -57,8 +56,4 @@ public static String formatForVisual(String origin) {
 
         return ExpressionUtils.addMultShortcut(origin);
     }
-
-    private static void clearBuilder() {
-        BUILDER.delete(0, BUILDER.length());
-    }
 }

Diff for: src/main/java/net/akami/mask/utils/MathUtils.java

@@ -48,7 +48,8 @@ public static String diffDivide(String a, String altA, String b, String altB) {
     public static String diffPow(String a, String altA, String b, String altB) {
         String subtractResult = subtract(b, "1");
         subtractResult = subtractResult.equals("1") ? "" : "^("+subtractResult+")";
-        return "("+mult(b, a)+")"+subtractResult;
+        b = ExpressionUtils.isReduced(b) || ExpressionUtils.areEdgesBracketsConnected(b) ? b+"*" : "("+b+")*";
+        return b+a+subtractResult;
     }
 
     public static String breakNumericalFraction(String self) {

Diff for: src/test/java/net/akami/mask/core/MainTester.java

@@ -1,7 +1,5 @@
 package net.akami.mask.core;
 
-import net.akami.mask.math.MaskExpression;
-import net.akami.mask.operation.MaskOperator;
 import net.akami.mask.utils.ReducerFactory;
 
 import java.util.Scanner;
@@ -10,21 +8,6 @@ public class MainTester {
 
     public static void main(String... args) {
 
-        //System.out.println("...............................");
-        //System.out.println(MathUtils.monomialSum("x^10", ""));
-        //System.out.println(MathUtils.highPow("x+1", "3"));
-        //operator.imageFor(MaskExpression.TEMP, false, res -> System.out.println(operator.asInt(res)), "1");
-
-        //System.out.println(MathUtils.simpleMult("5*x", "6*x"));
-        //System.out.println(MathUtils.pow("x+y+3", "3"));
-        //System.out.println(ReducerFactory.reduce("(x+y+3)^3"));
-        //System.out.println(MathUtils.pow("x+1", "2"));
-        //MaskExpression exp = new MaskExpression("3x^2 + 6xy + 3");
-        //System.out.println(MaskOperator.begin().differentiate(exp, MaskExpression.TEMP, 'x',true).asExpression());
-
-        //System.out.println(MathUtils.monomialSum("xx", "x^2"));
-        //MaskExpression exp = new MaskExpression("5x + 3y");
-        //System.out.println(MaskOperator.begin(exp).differentiate('y').asExpression());
         Scanner sc = new Scanner(System.in);
         String expression;
 
@@ -36,17 +19,5 @@ public static void main(String... args) {
             System.out.println("Calculations ended after "+deltaTime+" seconds");
             System.out.println("Next expression to reduce : ");
         }
-
-        //System.out.println(MathUtils.monomialSum(Arrays.asList("5", "-4", "-x", "3y", "4x")));
-        //System.out.println(MathUtils.subtract("5x", "3+x+2"));
-        //System.out.println(ReducerFactory.reduce("5+2"));
-        //System.out.println(ReducerFactory.reduce("3*((x+2y)*2 - 8z)"));
-        //System.out.println(ReducerFactory.reduce("((1+2)*3)*4"));
-        //System.out.println(ReducerFactory.reduce("(5x+4x)*7y"));
-        //System.out.println(ReducerFactory.reduce("(5x+3y)*3"));
-        //System.out.println(ReducerFactory.reduce("5x*y"));
-        //for(int i = 0; i<5000; i++)
-        //System.out.println(ReducerFactory.reduce("((2+7)^(23-19)-((3+9)*10))^3"));
-        //System.out.println(MathUtils.mult("5x+3y+8z+9w", "2x+3y+12z+4w"));
     }
 }

Diff for: src/test/java/net/akami/mask/operation/DerivativeTest.java

@@ -11,8 +11,8 @@ public void diffElementTest() {
         Assertions.assertThat(Derivative.differentiateElement("a")).isEqualTo("1");
         Assertions.assertThat(Derivative.differentiateElement("3")).isEqualTo("0");
         Assertions.assertThat(Derivative.differentiateElement("-1324")).isEqualTo("0");
-        Assertions.assertThat(Derivative.differentiateElement("x^2")).isEqualTo("(2x)");
-        Assertions.assertThat(Derivative.differentiateElement("x^(y+1)")).isEqualTo("(xy+x)^(y)");
+        Assertions.assertThat(Derivative.differentiateElement("x^2")).isEqualTo("2*x");
+        Assertions.assertThat(Derivative.differentiateElement("x^(y+1)")).isEqualTo("(y+1)*x^(y)");
 
     }
 }

Diff for: src/test/java/net/akami/mask/utils/MathUtilsTest.java

@@ -72,7 +72,7 @@ public void diffDivideTest() {
     @Test
     public void diffPowTest() {
         QuaternaryMathOperation sum = MathUtils::diffPow;
-        Assertions.assertThat(sum.compute("3x", "3", "3", "0")).isEqualTo("(9x)^(2)");
-        Assertions.assertThat(sum.compute("-5x", "-5", "x+1", "1")).isEqualTo("(-5x^2-5x)^(x)");
+        Assertions.assertThat(sum.compute("3x", "3", "3", "0")).isEqualTo("3*3x^(2)");
+        Assertions.assertThat(sum.compute("-5x", "-5", "x+1", "1")).isEqualTo("(x+1)*-5x^(x)");
     }
 }