Merge pull request #2 from MarcellPerger1/add-pow

Add PowOperation

Author: MarcellPerger1

.devcontainer/devcontainer.json

@@ -0,0 +1,31 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/java
+{
+	"name": "Java",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/java:1-21-bullseye",
+
+	"features": {
+		"ghcr.io/devcontainers/features/java:1": {
+			"version": "none",
+			"installMaven": "true",
+			"installGradle": "false"
+		},
+		"ghcr.io/devcontainers/features/python:1": {
+			"installTools": true,
+			"version": "3.11"
+		}
+	}
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "java -version",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

.github/dependabot.yml

@@ -0,0 +1,12 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for more information:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+# https://containers.dev/guide/dependabot
+
+version: 2
+updates:
+ - package-ecosystem: "devcontainers"
+   directory: "/"
+   schedule:
+     interval: weekly

src/main/java/net/marcellperger/mathexpr/BinOpBiConstructor.java

@@ -2,6 +2,9 @@
 
 
 @FunctionalInterface
-public interface BinOpBiConstructor<R extends MathSymbol> {
-    R construct(MathSymbol left, MathSymbol right);
+public interface BinOpBiConstructor {
+    // NOTE: Not generic, but implementations will just return `MathSymbol`
+    // (which is allowed to be any subclass of MathSymbol) similar to
+    // `List<T> of(T... values)` can return any `List` implementation
+    MathSymbol construct(MathSymbol left, MathSymbol right);
 }

src/main/java/net/marcellperger/mathexpr/BinaryOperation.java

@@ -8,4 +8,8 @@ public interface BinaryOperation extends MathSymbol {
     default String fmt() {
         return "%s(%s, %s)".formatted(this.getClass().getSimpleName(), getLeft().fmt(), getRight().fmt());
     }
+
+    static MathSymbol construct(MathSymbol left, SymbolInfo op, MathSymbol right) {
+        return op.getBiConstructor().construct(left, right);
+    }
 }

src/main/java/net/marcellperger/mathexpr/BinaryOperationLeftRight.java

@@ -37,6 +37,11 @@ public MathSymbol getRight() {
         return SymbolInfo.infixFromClass(getClass());
     }
 
+    @Contract(pure = true)
+    public @Nullable String getSpacesAroundInfixInst() {
+        return SymbolInfo.spacesAroundInfixFromClass(getClass());
+    }
+
     @Contract(pure = true)
     public @Nullable GroupingDirection getGroupingDirectionInst() {
         return SymbolInfo.groupingDirectionFromClass(getClass());
@@ -46,9 +51,11 @@ public MathSymbol getRight() {
     public String fmt() {
         String infix = getInfixInst();
         if(infix == null) return BinaryOperation.super.fmt(); // fallback
-        return "%s %s %s".formatted(
+        return "%s%s%s%s%s".formatted(
                 left.fmtWithParensIfRequired(instPrecedenceInt(), _parensRequiredIfEqual(LeftRight.LEFT)),
+                getSpacesAroundInfixInst(),
                 infix,
+                getSpacesAroundInfixInst(),
                 right.fmtWithParensIfRequired(instPrecedenceInt(), _parensRequiredIfEqual(LeftRight.RIGHT)));
     }
 

src/main/java/net/marcellperger/mathexpr/MathSymbol.java

@@ -1,7 +1,6 @@
 package net.marcellperger.mathexpr;
 
 
-import net.marcellperger.mathexpr.util.Util;
 import org.jetbrains.annotations.Nullable;
 
 // TODO maybe make it required to have an entry in SymbolInfo
@@ -19,7 +18,7 @@ public interface MathSymbol {
      * just for a nicer syntax when we DO have an instance
      */
     default @Nullable Integer instPrecedenceInt() {
-        return Util.chainNulls(SymbolInfo.fromClass(this.getClass()), s -> s.precedence);
+        return SymbolInfo.precedenceFromClass(getClass());
     }
 
     default String fmtAlwaysParens() {

src/main/java/net/marcellperger/mathexpr/PrecedenceLevelInfo.java

@@ -0,0 +1,59 @@
+package net.marcellperger.mathexpr;
+
+import net.marcellperger.mathexpr.util.Util;
+import net.marcellperger.mathexpr.util.UtilCollectors;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Data for a specific precedence level
+ */
+public class PrecedenceLevelInfo {
+    public Set<SymbolInfo> symbols;
+    public Map<String, SymbolInfo> infixToSymbolMap;
+    public List<String> sortedInfixes;
+    public @Nullable GroupingDirection dirn;
+    public int precedence;
+
+    /**
+     * @param precedence_ The precedence level (gets data from SymbolInfo)
+     */
+    public PrecedenceLevelInfo(int precedence_) {
+        precedence = precedence_;
+        symbols = SymbolInfo.PREC_TO_INFO_MAP.get(precedence);
+        // Shouldn't be passed an empty level in the first place
+        Util.requireNonEmptyNonNull(symbols, "Cannot create PrecedenceLevelInfo for a level with no items");
+        dirn = symbols.stream()
+            .map(sm -> sm.groupingDirection).collect(UtilCollectors.singleDistinctItem());
+        try {
+            infixToSymbolMap = symbols.stream().collect(
+                Collectors.toMap(
+                    info -> Util.requireNonNull(info.infix, new NullInfixException()),
+                    info -> info));
+        } catch (NullInfixException e) {
+            // a precedence level should really be uniform so if any infix is null,
+            //  we set this to null. This may help avoid any subtle bugs later.
+            infixToSymbolMap = null;
+            sortedInfixes = null;
+        }
+        if(infixToSymbolMap != null) {
+            sortedInfixes = infixToSymbolMap.keySet().stream()
+                .sorted(Comparator.comparingInt(String::length).reversed()).toList();
+        }
+    }
+
+    @Contract("_ -> new")
+    public static Map.@NotNull Entry<Integer, PrecedenceLevelInfo> newMapEntry(int precedence) {
+        return Util.makeEntry(precedence, new PrecedenceLevelInfo(precedence));
+    }
+
+    /** Marker exception that we throw to signal that there should be no infix info at all */
+    private static class NullInfixException extends RuntimeException {}
+}

src/main/java/net/marcellperger/mathexpr/SymbolInfo.java

@@ -1,6 +1,7 @@
 package net.marcellperger.mathexpr;
 
 import net.marcellperger.mathexpr.util.Util;
+import net.marcellperger.mathexpr.util.UtilCollectors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -18,37 +19,44 @@
 
 public enum SymbolInfo {
     // Let's say that precedence 0 is for (parens) OR literals - TODO add a class?? but it wouldn't actually be used !
-    // POW(PowOperation.class, 1, GroupingDirection.RightToLeft, "**"),
-    MUL(MulOperation.class, 1, GroupingDirection.LeftToRight, "*", MulOperation::new),
-    DIV(DivOperation.class, 1, GroupingDirection.LeftToRight, "/", DivOperation::new),
+    POW(PowOperation.class, 1, GroupingDirection.RightToLeft, "**", "", PowOperation::new),
 
-    ADD(AddOperation.class, 2, GroupingDirection.LeftToRight, "+", AddOperation::new),
-    SUB(SubOperation.class, 2, GroupingDirection.LeftToRight, "-", SubOperation::new),
+    MUL(MulOperation.class, 2, GroupingDirection.LeftToRight, "*", " ", MulOperation::new),
+    DIV(DivOperation.class, 2, GroupingDirection.LeftToRight, "/", " ", DivOperation::new),
+
+    ADD(AddOperation.class, 3, GroupingDirection.LeftToRight, "+", " ", AddOperation::new),
+    SUB(SubOperation.class, 3, GroupingDirection.LeftToRight, "-", " ", SubOperation::new),
     ;
 
     public static final Map<Class<? extends MathSymbol>, SymbolInfo> CLS_TO_INFO_MAP;
     public static final Map<Integer, Set<SymbolInfo>> PREC_TO_INFO_MAP;
     public static final List<Entry<Integer, Set<SymbolInfo>>> PREC_SORTED_INFO;
+    public static final int MAX_PRECEDENCE;
+    public static final Map<Integer, PrecedenceLevelInfo> PREC_LEVELS_INFO;
 
     public final int precedence;  // TODO make this Integer
     public final Class<? extends MathSymbol> cls;
     public final GroupingDirection groupingDirection;
     public final String infix;
+    public final @Nullable String spacesAroundInfix;
 
+    @SuppressWarnings("unused")  // useful later
     SymbolInfo(Class<? extends MathSymbol> cls, int precedence,
-               GroupingDirection groupingDirection, @Nullable String infix) {
+               GroupingDirection groupingDirection, @Nullable String spacesAroundInfix, @Nullable String infix) {
         this.precedence = precedence;
-        this.cls = cls;  // TODO: private + getters?
+        this.cls = cls;
         this.groupingDirection = groupingDirection;
         this.infix = infix;
+        this.spacesAroundInfix = spacesAroundInfix;
     }
     SymbolInfo(Class<? extends BinaryOperationLeftRight> cls, int precedence,
-               GroupingDirection groupingDirection, @Nullable String infix,
-               BinOpBiConstructor<?> biConstructor) {
+               GroupingDirection groupingDirection, @Nullable String infix, @Nullable String spacesAroundInfix,
+               BinOpBiConstructor biConstructor) {
         this.precedence = precedence;
         this.cls = cls;  // TODO: private + getters?
         this.groupingDirection = groupingDirection;
         this.infix = infix;
+        this.spacesAroundInfix = spacesAroundInfix;
         this.biConstructorCache = biConstructor;
     }
 
@@ -66,11 +74,13 @@ public enum SymbolInfo {
     public static @Nullable String infixFromClass(Class<? extends MathSymbol> cls) {
         return Util.chainNulls(fromClass(cls), x -> x.infix);
     }
+    public static @Nullable String spacesAroundInfixFromClass(Class<? extends MathSymbol> cls) {
+        return Util.chainNulls(fromClass(cls), s -> s.spacesAroundInfix);
+    }
 
-    private BinOpBiConstructor<?> biConstructorCache = null;
-    public @NotNull BinOpBiConstructor<?> getBiConstructor() {
+    private BinOpBiConstructor biConstructorCache = null;
+    public @NotNull BinOpBiConstructor getBiConstructor() {
         if(biConstructorCache != null) return biConstructorCache;
-        // TODO could add a BiFunction<> arg to SymbolInfo(), then pass AddOperation::new etc.
         assert BinaryOperationLeftRight.class.isAssignableFrom(cls);
 
         Constructor<? extends BinaryOperationLeftRight> ctor;
@@ -104,5 +114,7 @@ public enum SymbolInfo {
         CLS_TO_INFO_MAP = Arrays.stream(values()).collect(Collectors.toUnmodifiableMap(p -> p.cls, p -> p));
         PREC_TO_INFO_MAP = Arrays.stream(values()).collect(Collectors.groupingBy(s -> s.precedence, Collectors.toUnmodifiableSet()));
         PREC_SORTED_INFO = PREC_TO_INFO_MAP.entrySet().stream().sorted(Comparator.comparingInt(Entry::getKey)).toList();
+        MAX_PRECEDENCE = PREC_SORTED_INFO.getLast().getKey();
+        PREC_LEVELS_INFO = PREC_TO_INFO_MAP.keySet().stream().map(PrecedenceLevelInfo::newMapEntry).collect(UtilCollectors.entriesToMap());
     }
 }