week4 alusosa lahendused

Author: sim642

sols/toylangs/bolog/BologEvaluator.java

@@ -0,0 +1,29 @@
+package toylangs.bolog;
+
+import toylangs.bolog.ast.*;
+
+import java.util.List;
+import java.util.Set;
+
+public class BologEvaluator {
+    private final Set<String> trueVars;
+
+    public BologEvaluator(Set<String> trueVars) {
+        this.trueVars = trueVars;
+    }
+
+    public static boolean eval(BologNode node, Set<String> trueVars) {
+        BologEvaluator bologEvaluator = new BologEvaluator(trueVars);
+        return bologEvaluator.eval(node);
+    }
+
+    private boolean eval(BologNode node) {
+        return switch (node) {
+            case BologLit(boolean value) -> value;
+            case BologVar(String name) -> trueVars.contains(name);
+            case BologNand(BologNode left, BologNode right) -> !(eval(left) && eval(right));
+            case BologImp(BologNode conclusion, List<BologNode> assumptions) ->
+                    eval(conclusion) || !assumptions.stream().allMatch(this::eval);
+        };
+    }
+}

sols/toylangs/dialoog/DialoogEvaluator.java

@@ -0,0 +1,70 @@
+package toylangs.dialoog;
+
+import toylangs.dialoog.ast.*;
+
+import java.util.*;
+
+import static toylangs.dialoog.ast.DialoogNode.*;
+
+public class DialoogEvaluator {
+
+    public static class UndeclaredVariableException extends RuntimeException {
+        public UndeclaredVariableException(String variable) {
+            super("Variable \"" + variable + "\" has not been declared.");
+        }
+    }
+
+    private final Map<String, Object> env;
+    private final HashSet<Object> declarations = new HashSet<>();
+
+    public DialoogEvaluator(Map<String, Object> env) {
+        this.env = env;
+    }
+
+    public static Object eval(DialoogProg prog, Map<String, Object> env) {
+        DialoogEvaluator dialoogEvaluator = new DialoogEvaluator(env);
+        return dialoogEvaluator.eval(prog);
+    }
+
+    private Object eval(DialoogNode node) {
+        return switch (node) {
+            case DialoogLitInt(int value) -> value;
+            case DialoogLitBool(boolean value) -> value;
+            case DialoogVar(String name) -> {
+                if (declarations.contains(name)) yield env.get(name);
+                throw new UndeclaredVariableException(name);
+            }
+            case DialoogDecl(String name, _) -> {
+                declarations.add(name);
+                yield null;
+            }
+            case DialoogUnary(DialoogUnary.UnOp op, DialoogNode expr) -> op.toJava().apply(eval(expr));
+            case DialoogBinary(DialoogBinary.BinOp op, DialoogNode leftExpr, DialoogNode rightExpr) -> {
+                Object v1 = eval(leftExpr);
+                Object v2 = eval(rightExpr);
+                yield op.toJava().apply(v1, v2);
+            }
+            case DialoogProg(List<DialoogDecl> decls, DialoogNode expr) -> {
+                for (DialoogDecl decl : decls)
+                    eval(decl);
+                yield eval(expr);
+            }
+            case DialoogTernary(DialoogNode guardExpr, DialoogNode trueExpr, DialoogNode falseExpr) -> {
+                Object evaluatedGuardExpr = eval(guardExpr);
+                assert evaluatedGuardExpr != null;
+                boolean guard = (boolean) evaluatedGuardExpr;
+                yield guard ? eval(trueExpr) : eval(falseExpr);
+            }
+        };
+    }
+
+    static void main() {
+        DialoogProg prog = prog(
+                decls(iv("x"), bv("a")),
+                ifte(var("a"), var("x"), il(0)));
+        Map<String, Object> env = new HashMap<>();
+        env.put("a", true);
+        env.put("x", 7);
+        System.out.println(eval(prog, env));
+    }
+}

sols/toylangs/hulk/HulkEvaluator.java

@@ -0,0 +1,78 @@
+package toylangs.hulk;
+
+import toylangs.hulk.ast.*;
+
+import java.util.*;
+
+import static toylangs.hulk.ast.HulkNode.*;
+
+public class HulkEvaluator {
+    private final Map<Character, Set<Character>> env;
+
+    public HulkEvaluator(Map<Character, Set<Character>> initialEnv) {
+        this.env = new HashMap<>(initialEnv); // teeme koopia, sest initialEnv pole muudetav
+    }
+
+    public static Map<Character, Set<Character>> eval(HulkProg prog, Map<Character, Set<Character>> initialEnv) {
+        HulkEvaluator hulkEvaluator = new HulkEvaluator(initialEnv);
+        hulkEvaluator.evalProg(prog);
+        return hulkEvaluator.env;
+    }
+
+    private void evalProg(HulkProg prog) {
+        for (HulkStmt stmt : prog.statements()) {
+            // evalCond haldab tingimuslauseid
+            if (stmt.cond() == null || evalCond(stmt.cond())) {
+                Set<Character> elements = evalExpr(stmt.expr());
+                env.put(stmt.name(), elements);
+            }
+        }
+    }
+
+    private Set<Character> evalExpr(HulkExpr node) {
+        return switch (node) {
+            case HulkLit(Set<Character> elements) -> elements;
+            case HulkVar(Character name) -> {
+                if (env.containsKey(name))
+                    yield env.get(name);
+                else
+                    throw new NoSuchElementException(name.toString());
+            }
+            case HulkBinOp(Character op, HulkExpr left, HulkExpr right) -> {
+                Set<Character> leftValue = evalExpr(left);
+                Set<Character> rightValue = evalExpr(right);
+                assert leftValue != null;
+                assert rightValue != null;
+                Set<Character> result = new HashSet<>(leftValue);
+                switch (op) {
+                    case '+' -> result.addAll(rightValue);
+                    case '-' -> result.removeAll(rightValue);
+                    case '&' -> result.retainAll(rightValue);
+                }
+                yield result;
+            }
+        };
+    }
+
+    private boolean evalCond(HulkCond cond) {
+        Set<Character> subset = evalExpr(cond.subset());
+        Set<Character> superset = evalExpr(cond.superset());
+        assert superset != null;
+        assert subset != null;
+        return superset.containsAll(subset);
+    }
+
+    static void main() {
+        ArrayList<HulkStmt> laused = new ArrayList<>();
+        laused.add(stmt('A', lit('a'), null));  // A := {a}
+        laused.add(stmt('B', lit('b'), null));  // B := {b}
+        laused.add(stmt('D', binop('+', var('A'), var('B')), null));  // D := (A+B)
+        HulkProg s = prog(laused);
+        System.out.println(s);
+        System.out.println();
+
+        Map<Character, Set<Character>> env = new HashMap<>();
+        eval(s, env);
+        System.out.println(env);  // {A=[a], B=[b], D=[a, b]}
+    }
+}

sols/toylangs/imp/ImpEvaluator.java

@@ -0,0 +1,36 @@
+package toylangs.imp;
+
+import toylangs.imp.ast.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ImpEvaluator {
+    private final Map<Character, Integer> env = new HashMap<>();
+
+    public static int eval(ImpProg prog) {
+        ImpEvaluator impEvaluator = new ImpEvaluator();
+        return impEvaluator.evalNode(prog);
+    }
+
+    private int evalNode(ImpNode node) {
+        return switch (node) {
+            case ImpNum(int value) -> value;
+            case ImpNeg(ImpNode exp) -> -evalNode(exp);
+            case ImpAdd(ImpNode left, ImpNode right) -> evalNode(left) + evalNode(right);
+            case ImpDiv(ImpNode numerator, ImpNode denominator) -> evalNode(numerator) / evalNode(denominator);
+            case ImpVar(char name) -> env.get(name);
+            case ImpAssign(char name, ImpNode exp) -> {
+                env.put(name, evalNode(exp));
+                yield 0; // tegelikkuses pole tagastusväärtust
+            }
+            case ImpProg(ImpNode exp, List<ImpAssign> assigns) -> {
+                for (ImpAssign assign : assigns) {
+                    evalNode(assign); // tagastusväärtust 0 ignoreeritakse
+                }
+                yield evalNode(exp);
+            }
+        };
+    }
+}

sols/toylangs/modul/ModulEvaluator.java

@@ -0,0 +1,56 @@
+package toylangs.modul;
+
+import toylangs.modul.ast.*;
+
+import java.util.Map;
+
+public class ModulEvaluator {
+    private final int m;
+    private final Map<String, Integer> env;
+
+    protected ModulEvaluator(int m, Map<String, Integer> env) {
+        this.m = m;
+        this.env = env;
+    }
+
+    public static int eval(ModulProg prog, Map<String, Integer> env) {
+        ModulEvaluator modulEvaluator = new ModulEvaluator(prog.modulus(), env);
+        return modulEvaluator.eval(prog.expr());
+    }
+
+    protected int eval(ModulExpr expr) {
+        int result = switch (expr) {
+            case ModulNum(int value) -> value;
+            case ModulVar(String name) -> {
+                Integer value = env.get(name);
+                if (value == null)
+                    throw new ModulException();
+                else
+                    yield value;
+            }
+            case ModulNeg(ModulExpr subExpr) -> -eval(subExpr);
+            case ModulAdd(ModulExpr left, ModulExpr right) -> eval(left) + eval(right);
+            case ModulMul(ModulExpr left, ModulExpr right) -> eval(left) * eval(right);
+            case ModulPow(ModulExpr base, int power) -> evalPow(base, power);
+        };
+
+        return normalize(result); // ModulPow korral üleliigne
+    }
+
+    // Eraldi meetod, et ModulMaster saaks taaskasutada.
+    protected int evalPow(ModulExpr base, int power) {
+        int baseValue = eval(base);
+        int result = 1;
+        for (int i = 0; i < power; i++) {
+            result = normalize(result * baseValue);
+        }
+        return result;
+    }
+
+    /**
+     * Normaliseerib väärtuse poollõiku [0, m).
+     */
+    protected int normalize(int value) {
+        return ((value % m) + m) % m; // negatiivsete arvude jaoks keerulisem
+    }
+}