Clerk.clear();

Clerk.markdown("""

""");

Clerk.markdown(Text.fillOut("""

""", Text.codeBlock("./Turtle.java", "// cut-out")));

Clerk.markdown("Im Folgenden wird die Funktionsweise des Funktionsplotters beschrieben");

Clerk.markdown("""

""");

// Beispielwerte

// out example 1

String infix_example = "2 * x ^ 3 + e^x + x / 3 - pi"; // Expression 1

Expr infix_example_expr = Parser.parse(infix_example);

// out example 1

// out example 2

String upn_example = "x 2 ^ 4 + sqrt x 3 / ln +"; // Expression 2

Expr upn_example_expr = Parser.parse(upn_example);

// out example 2

// out example 3

String infix_example_v2 = "log_3(27) + sqrt(9) * e ^ pi "; // Expression 3

String res_infix_v2 = printExpression(infix_example_v2);

// out example 3

// out example 4

String upn_example_v2 = "45 tan 16 sqrt /"; // Expression 4

String res_upn_v2 = printExpression(upn_example_v2);

// out example 4

Clerk.markdown("*1. Der arithmetische Ausdruck, der eine Variable x enthält, kann als Infix-Notation eingegeben werden: <br>*");

Clerk.write(Interaction.input("./funktionsplotter.java", "// Expression 1", "String infix_example = \"$\";", "Eingabe in Infix-Notation"));

Clerk.markdown(String.format("Es wurde eingegeben: $%s$ <br>", infix_example));

Clerk.markdown("Der Infix-Ausdruck (mit Variable) wird vom Parser geparsed und der entsprechende AST-Baum generiert: <br>" + infix_example_expr.toString());

Clerk.markdown(Text.fillOut("""

""", Text.codeBlock("./funktionsplotter.java", "// out example 1")));

Clerk.markdown("*2. Der arithmetische Ausdruck, der eine Variable x enthält, kann als UPN-Notation eingegeben werden: <br>*");

Clerk.write(Interaction.input("./funktionsplotter.java", "// Expression 2", "String upn_example = \"$\";", "Eingabe in UPN-Notation"));

Clerk.markdown(String.format("Es wurde eingegeben: %s <br>", upn_example));

Clerk.markdown("Der UPN-Ausdruck (mit Variable) wird vom Parser geparsed und der entsprechende AST-Baum generiert: <br>" + upn_example_expr.toString());

Clerk.markdown(Text.fillOut("""

""", Text.codeBlock("./funktionsplotter.java", "// out example 2")));

Clerk.markdown("*3. Der arithmetische Ausdruck als Infix-Notation (ohne Variable) kann direkt ausgewertet werden: <br>*");

Clerk.write(Interaction.input("./funktionsplotter.java", "// Expression 3", "String infix_example_v2 = \"$\";", "Eingabe in Infix-Notation"));

Clerk.markdown("Die direkte Auswertung: " + res_infix_v2);

// Clerk.markdown("Der Infix-Ausdruck (ohne Variable) wird vom Parser geparsed und der entsprechende AST-Baum generiert: <br>" + infix_example_expr.toString());

Clerk.markdown(Text.fillOut("""

""", Text.codeBlock("./funktionsplotter.java", "// out example 3"),

Text.codeBlock("./funktionsplotter.java", "// print Expression"),

Text.codeBlock("./funktionsplotter.java", "// cut out tryEval")));

Clerk.markdown("*4.Der arithmetische Ausdruck als UPN-Notation kann direkt ausgewertet werden: <br>*");

Clerk.write(Interaction.input("./funktionsplotter.java", "// Expression 4", "String upn_example_v2 = \"$\";", "Eingabe in UPN-Notation"));

Clerk.markdown("Die direkte Auswertung: " + res_upn_v2);

Clerk.markdown("""

""");

Clerk.markdown("""

""");

// cut out beispiel anzeige

// String example_expr_v3_str = "x^3 + sin(x)^(log_6(x * cos(pi)) / sqrt(4)"; // FEHLER

String example_expr_v3_str = "~x^3 + sin(x)^log_6(x * cos(pi)) / sqrt(4)";

String example_expr_v3_upn_str = "x 3 ^ ~ x sin x pi cos * log_6 ^ 4 sqrt / +";

Expr example_expr_v3 = Parser.parse(example_expr_v3_str);

Expr example_expr_v3_upn = Parser.parse(example_expr_v3_upn_str);

ASTVisualisation ast_visualisation = new ASTVisualisation();

String dot2_syntax = ast_visualisation.toDot(example_expr_v3);

String dot3_syntax = ast_visualisation.toDot(example_expr_v3_upn);

// cut out beispiel anzeige

Clerk.markdown("Es wurden bereits im Abschnitt \"*Eingabe*\" die Ausdrücke in abstrakter Syntax angezeigt");

Clerk.markdown("Hier ein weiteres Beispiel: " + example_expr_v3_str);

Clerk.markdown("Der entsprechende AST-Baum: <br>" + example_expr_v3.toString());

Clerk.markdown("Dieser AST lässt sich mithilfe der DOT-Sprache darstellen:");

// display dot graph 1

new Dot().draw(dot2_syntax);

// display dot graph 1

Clerk.markdown("Die gleiche Funktion nur in UPN-Schreibweise: " + example_expr_v3_upn_str);

Clerk.markdown(String.format("Der entsprechende AST-Baum aus dem UPN-Ausdruck: <br> %s", example_expr_v3_upn));

Clerk.markdown("Die gleiche Funktion nur in UPN-Schreibweise generiert den gleichen DOT-Graphen: ");

// display dot graph 2

new Dot().draw(dot3_syntax);

// display dot graph 2

Clerk.markdown("Die dazugehörige generierte DOT-Syntax sieht folgendermaßen aus: <br>" + dot2_syntax);

Clerk.markdown(Text.fillOut("""

""", Text.codeBlock("./funktionsplotter.java", "// AST Vis cut"),

Text.codeBlock("./funktionsplotter.java", "// cut out beispiel anzeige"),

Text.codeBlock("./funktionsplotter.java", "// display dot graph 1"),

Text.codeBlock("./funktionsplotter.java", "// display dot graph 2")

));

Clerk.markdown("Jetzt wird ausgehend von der abstrakten Syntax bzw. dem AST-Baum die Repräsentation in Infix- und UPN-Schreibweise angezeigt");

Clerk.markdown(String.format("Es wird das vorherige Beispiel verwendet: %s <br>", example_expr_v3_str));

Clerk.markdown(String.format("*Abstrakte Syntax:* `%s` <br>", example_expr_v3.toString()));

// generators

String infix_notation = InfixGenerator.generate(example_expr_v3);

String upn_notation = UPNGenerator.generate(example_expr_v3);

// generators

Clerk.markdown(String.format("Aus der Abstrakten Syntax wird der Infix-Ausdruck und der UPN-Ausdruck ausgewertet. <br> *Infix:* %s <br> *UPN:* %s", infix_notation, upn_notation));

Clerk.markdown(Text.fillOut("""

""", Text.codeBlock("./funktionsplotter.java", "// generators"),

Text.codeBlock("./funktionsplotter.java", "// plotter playground")

));

// tokenizer example

List<Token> tokens_example = ArithmeticTokenizer.tokenize("4 + x / log_5(3) ^ sin(x*2)");

String tokens_example_str = tokens_example.toString();

// tokenizer example

Clerk.markdown(Text.fillOut(String.format("""

""", tokens_example_str),

Text.codeBlock("./funktionsplotter.java", "// cut Expr SI"),

Text.codeBlock("./funktionsplotter.java", "// tokenizer example"),

Text.codeBlock("./funktionsplotter.java", "// cut combined parse")

));

Clerk.markdown(Text.fillOut("""

""", Text.codeBlock("./funktionsplotter.java", "// cut farbgen")));

Clerk.markdown("""

""");

Clerk.markdown(Text.fillOut("""

""", Text.codeBlock("./funktionsplotter.java", "// cut out param erweiterung")

));

// cut out param erweiterung

Plotter p2 = new Plotter(-15, 15, -10, 16);

Expr first_expr_p2 = Parser.parse("a * x^2 - a * 1/5");

Expr second_expr_p2 = Parser.parse("a * sin(x - pi / 4) + 1");

//p2.redraw();

//p2.plotFunctionWithParams(first_expr_p2, "a", 2.0, 4.0, 5.0);

//p2.plotFunctionWithParams(second_expr_p2, "a", -1.0, 3.0, 8.0, 11.0);

//p2.startTurtle();

// cut out param erweiterung

Clerk.markdown("""

""");

Plotter p3 = new Plotter(-20, 20, -20, 20);

Expr normal_expr = Parser.parse("x^4 + 5*x + 9");

Expr first_derived_expr = Differentiator.derive(normal_expr); // 4 * x^3 + 5

Expr second_derived_expr = Differentiator.derive(first_derived_expr); // 12 * x^2

Expr third_derived_expr = Differentiator.derive(second_derived_expr); // 24 * x

Expr example_e = Parser.parse("(3*x^2 - 1)/(e^(2*x^3) + 4*x)");

Expr first_derived_example_e = Differentiator.derive(example_e);

Expr first_derived_example_e_simplified = Differentiator.simplify(first_derived_example_e);

Expr second_derived_example_e = Differentiator.derive(first_derived_example_e);

Expr second_derived_example_e_simplified = Differentiator.simplify(second_derived_example_e);

InfixGenerator infixGen = new InfixGenerator();

String example_e_infix = infixGen.generate(example_e);

String first_derived_example_e_infix = infixGen.generate(first_derived_example_e);

String second_derived_example_e_infix = infixGen.generate(second_derived_example_e);

Clerk.markdown("**Erste Ableitung vor Vereinfachung:** " + infixGen.generate(first_derived_example_e));

Clerk.markdown("**Erste Ableitung nach Vereinfachung:** " + infixGen.generate(first_derived_example_e_simplified));

Clerk.markdown("**Zweite Ableitung vor Vereinfachung:** " + infixGen.generate(second_derived_example_e));

Clerk.markdown("**Zweite Ableitung nach Vereinfachung:** " + infixGen.generate(second_derived_example_e_simplified));

p3.redraw();

//p3.plotFunction(normal_expr);

//p3.plotFunction(first_derived_expr);

//p3.plotFunction(second_derived_expr);

//p3.plotFunction(third_derived_expr);

//p3.plotFunction(tangens_func);

p3.plotFunction(example_e);

p3.plotFunction(first_derived_example_e);

p3.plotFunction(second_derived_example_e);

p3.startTurtle();

Clerk.markdown("""

""");

Clerk.markdown(Text.fillOut("""

""", Text.codeBlock("./funktionsplotter.java", "// Funktionen"),

Text.codeBlock("./funktionsplotter.java", "// Eingabe Param"),

Text.codeBlock("./funktionsplotter.java", "// plotter playground")

));

// Funktionen

String[] examples = {

"2 * e^x * x^2",

"x^(6*x) + 5",

"(3*x^2 - 1)/(e^(2*x^3) + 4*x)",

//"sin(x) + cos(x)", // Infix mit Funktion

//sqrt(x+4)"

//"a * e^x + 6",

//"4*x^3 + log_4(x)",

//"1/x",

//"45 cos 10 * 9 sqrt +",

//"x^4 + 5*x + 9",

//"4*x^3 + 5",

//"3 x 2 ^ * 5 -", // UPN mit Variable

// "x sin x cos +", // UPN mit Funktion

// "(6 + 2) * 2", // Infix mit Klammern

// "6 + 2 * 5", // Infix ohne Klammern

// "6 + (2 * 5)", // Infix mit Klammern

// "~x+2",

//"e^2",

// "1/x",

// "x^3 - 2 * x",

// "sin(x)*5",

// "ln(x)",

// "e^x",

};

// Funktionen

// Eingabe Param

double[] parameterValues = {

1.0,

3.0,

-1.5,

};

// Eingabe Param

// plotter playground

Plotter plotter = new Plotter(-15, 20, -10, 30); // (xMin, xMax, yMin, yMax)

// plotter playground

// plotter.setParam("a", 1.0);

Map<Expr, String> exprToDot = new HashMap<>();

Map<Expr, String> exprToOriginal = new HashMap<>();

for (String example : examples) {

try {

Expr expr = Parser.parse(example);

exprToOriginal.put(expr, example);

ASTVisualisation ast_vis = new ASTVisualisation();

String dot_string = ast_vis.toDot(expr);

exprToDot.put(expr, dot_string);

// ???

} catch (IllegalArgumentException e) {

Clerk.markdown("Error: " + e.getMessage());

}

}

plotter.redraw();

plotter.plotMultipleFunctions(new ArrayList<>(exprToDot.keySet()), parameterValues);

plotter.startTurtle();

int func_counter = 1;

Clerk.markdown("### Funktionsübersicht:");

for (Expr expr : new ArrayList<>(exprToDot.keySet())) {

Clerk.markdown("--- ");

int[] colorsRGB = plotter.functionColors.get(expr);

Clerk.markdown(String.format("**<span style=\"color: rgb(%d,%d,%d)\">Funktion Nr.%s**</span>", colorsRGB[0], colorsRGB[1], colorsRGB[2], func_counter));

// DOT-Graph Anzeige

Clerk.markdown(String.format("**DOT-Syntax:** <br> %s", exprToDot.get(expr)));

Clerk.markdown("**DOT-Graph:**");

new Dot().draw(exprToDot.get(expr));

if (!expr.containsVar() && !expr.containsParameter()) {

// Unmittelbare Auswertung

String originalExpr = exprToOriginal.get(expr);

Clerk.markdown(String.format("**Direkte Auswertung:** %s", printExpression(originalExpr)));

}

else if (expr.containsParameter()) {

Clerk.markdown(String.format("Benutzte Parameterwerte: %s", Arrays.toString(parameterValues)));

Clerk.markdown("**Direkte Auswertung:** Nicht möglich, da der Ausdruck eine Variable oder Parameter enthält.");

}

else {

Clerk.markdown("**Direkte Auswertung:** Nicht möglich, da der Ausdruck eine Variable enthält.");

}

// INFIX Ausgabe

String infix_output = InfixGenerator.generate(expr);

Clerk.markdown(String.format("**Infix:** %s", infix_output));

// UPN Ausgabe

String rpn_output = UPNGenerator.generate(expr);

Clerk.markdown(String.format("**UPN:** %s", rpn_output));

func_counter++;

}

String fallbackText = "Keine unmittelbare Auswertung möglich";

return Parser.parse(exprStr)

.tryEval()

.map(res -> String.format("%s = %.3f", exprStr, res))

.orElse(fallbackText);

private final double MARGIN = 1.5;

private final double DRAW_STEPS = 0.01;

double plotXMin, plotXMax, plotYMin, plotYMax;

double displayXMin, displayXMax, displayYMin, displayYMax;

Turtle turtle;

private final ColorGenerator colorGenerator = new ColorGenerator();

private final Map<Expr, int[]> functionColors = new HashMap<>();

private Map<String, Double> parameters = new HashMap<>();

public Plotter(double xMin, double xMax, double yMin, double yMax) {

assert xMin < xMax : "xMin darf nicht größer sein als xMax";

assert yMin < yMax : "yMin darf nicht größer sein yMax";

this.plotXMin = xMin;

this.plotXMax = xMax;

this.plotYMin = yMin;

this.plotYMax = yMax;

updateDisplayBounds();

turtle = new Turtle(displayXMin, displayXMax, displayYMin, displayYMax, (plotXMin + plotXMax)/2, (plotYMin + plotYMax)/2, 0);

turtle.color(0, 0, 0).width(0.1);

}

private void updateDisplayBounds() {

this.displayXMin = plotXMin - MARGIN;

this.displayXMax = plotXMax + MARGIN;

this.displayYMin = plotYMin - MARGIN;

this.displayYMax = plotYMax + MARGIN;

}

void draw_coordinate_axes() {

// Rahmen für den Plotbereich

turtle.color(150, 150, 150).width(0.125);

turtle.penUp().moveTo(plotXMin, plotYMin).penDown();

turtle.moveTo(plotXMax, plotYMin);

turtle.moveTo(plotXMax, plotYMax);

turtle.moveTo(plotXMin, plotYMax);

turtle.moveTo(plotXMin, plotYMin);

// Hilfslinien (grau)

turtle.color(200, 200, 200).width(0.05);

// Vertikale Hilfslinien

for (double x = Math.ceil(plotXMin); x <= Math.floor(plotXMax); x++) {

turtle.penUp().moveTo(x, plotYMin).penDown().moveTo(x, plotYMax);

// Beschriftung X-Achse

turtle.penUp().moveTo(x, plotYMin).setAngle(265); // Zeigt nach unten

turtle.forward(1.75); // Etwas Abstand von der Achse

turtle.text(String.valueOf((int) x), "0.5px sans-serif");

}

// Horizontale Hilfslinien

for (double y = Math.ceil(plotYMin); y <= Math.floor(plotYMax); y++) {

turtle.penUp().moveTo(plotXMin, y).penDown().moveTo(plotXMax, y);

// Beschriftung links der Y-Achse

turtle.penUp().moveTo(plotXMin, y).setAngle(240); // Zeigt nach links

turtle.forward(1.275); // Etwas Abstand von der Achse

turtle.text(String.valueOf((int) y), "0.5px sans-serif");

}

// Hauptachsen (schwarz)

turtle.color(0, 0, 0);

turtle.width(0.075);

// X-Achse (nur innerhalb des Plotbereichs zeichnen)

turtle.penUp().moveTo(plotXMin, 0).penDown().moveTo(plotXMax, 0);

// Y-Achse (nur innerhalb des Plotbereichs zeichnen)

turtle.penUp().moveTo(0, plotYMin).penDown().moveTo(0, plotYMax);

}

void plotFunction(Expr expr) {

plotFunctionCustom(expr, plotXMin, plotXMax);

}

void plotFunctionWithParams(Expr expr, String p, double... params) {

Arrays.stream(params).forEach(par -> {

setParam(p, par);

plotFunction(expr);

});

}

void plotFunctionCustom(Expr expr, double xMin, double xMax) {

turtle.width(0.075); // Liniendicke

boolean penDown = false;

double lastValidX = xMin;

double lastValidY = 0;

double stepSize = DRAW_STEPS;

for (double x = xMin; x <= xMax; x += stepSize) {

try {

double y = eval(expr, x);

// Prüfe ob Punkt innerhalb des definierten Bereichs liegt

boolean isInBounds = y >= plotYMin && y <= plotYMax;

boolean isValid = !Double.isNaN(y) && !Double.isInfinite(y);

if (isValid && isInBounds) {

if (!penDown) {

// Neuen Abschnitt beginnen

turtle.penUp().moveTo(x, y).penDown();

penDown = true;

} else {

// Prüfe auf Diskontinuität (große Sprünge)

double deltaX = x - lastValidX;

double deltaY = Math.abs(y - lastValidY);

double yRange = plotYMax - plotYMin;

double discontinuityThreshold = yRange * 0.2;

if (deltaY > discontinuityThreshold && deltaX > DRAW_STEPS * 2) {

// Linie unterbrechen bei großen Sprüngen

turtle.penUp().moveTo(x, y).penDown();

} else {

turtle.moveTo(x, y);

}

}

lastValidX = x;

lastValidY = y;

} else {

// Punkt außerhalb des Bereichs -> Stift anheben

penDown = false;

}

} catch (ArithmeticException e) {

penDown = false;

}

}

}

void plotMultipleFunctions(List<Expr> functions) {

functions.forEach(function -> {

int[] color = functionColors.computeIfAbsent(function, e -> colorGenerator.getNextColor());

turtle.color(color[0], color[1], color[2]);

plotFunction(function);

});

}

void plotMultipleFunctions(List<Expr> functions, double... params) {

functions.forEach(function -> {

int[] color = functionColors.computeIfAbsent(function, e -> colorGenerator.getNextColor());

functionColors.put(function, color);

turtle.color(color[0], color[1], color[2]);

if (function.containsParameter()) {

plotFunctionWithParams(function, "a", params);

}

else {

plotFunction(function);

}

});

}

public void setParam(String name, double value) {

parameters.put(name, value);

}

double eval(Expr expr, double x) {

return switch(expr) {

case Expr.Number num -> num.value();

case Expr.Variable v -> x;

case Expr.UnaryOp(Operator op, Expr e)-> {

double value = eval(e, x);

yield switch (op) {

case NEG -> -value;

default -> throw new UnsupportedOperationException("Unary-Operator " + op + " wird nicht unterstützt");

};

}

case Expr.BinaryOp(Operator op, Expr l, Expr r) -> {

double left = eval(l, x);

double right = eval(r, x);

yield switch(op) {

case ADD -> left + right;

case SUB -> left - right;

case MUL -> left * right;

case DIV -> left / right;

case POW -> Math.pow(left, right);

default -> throw new UnsupportedOperationException("Binary-Operator " + op + " wird nicht unterstützt");

};

}

case Expr.FunctionCall(Function func, Expr arg) -> {

double value = eval(arg, x);

yield switch(func) {

case SIN -> Math.sin(value);

case COS -> Math.cos(value);

case TAN -> Math.tan(value);

case LOG -> Math.log10(value);

case LN -> Math.log(value);

case SQRT -> Math.sqrt(value);

case EXP -> Math.exp(value);

default -> throw new UnsupportedOperationException("Funktion " + func + " wird nicht unterstützt");

};

}

case Expr.Constant(Const c) -> switch (c) {

case PI -> Math.PI;

case E -> Math.E;

};

case Expr.LogBase(Double base, Expr arg) -> {

double value = eval(arg, x);

yield Math.log(value) / Math.log(base);

}

case Expr.Parameter p -> {

Double val = parameters.get(p.name());

if (val == null) throw new ArithmeticException("Parameter " + p.name() + " ist nicht gesetzt");

yield val;

}

};

}

Turtle redraw() {

turtle.penUp().moveTo(0, 0).setAngle(0); // Turtle zurücksetzen

draw_coordinate_axes(); // Koordinatensystem zeichnen

return turtle;

}

Turtle startTurtle() {

Clerk.markdown("### Funktionsgraph: ");

this.turtle = turtle.write();

return turtle;

}

private static final float GOLDEN_NUM = 1.618033988749895f;

private float hue = 0;

public int[] getNextColor() {

hue += GOLDEN_NUM;

hue %= 1; // Bleibt im Bereich [0,1]

// HSB zu RGB: Sättigung 90%, Helligkeit 95%

int rgb = Color.HSBtoRGB(hue, 0.9f, 0.95f);

return new int[] {

(rgb >> 16) & 0xFF, // Rot

(rgb >> 8) & 0xFF, // Grün

rgb & 0xFF // Blau

};

}

public static List<Token> tokenize(String input) {

return new Tokenizer(input).tokenize();

}

private static class Tokenizer {

private static final Pattern TOKEN_PATTERN = Pattern.compile(

"(?<NUM>\\d+\\.?\\d*)|" + // Zahlen

"(?<FUNC>sin|cos|tan|log_\\d+|log|ln|sqrt|exp)|" + // Funktionen

"(?<CONST>pi|e)|" + // Konstanten

"(?<PAR>a)|" + // Parameter

"(?<VAR>[b-zB-Z][b-zB-Z0-9]*)|" + // Variablen

"(?<OP>[+\\-*/~^])|" + // Operatoren

"(?<PAREN>[()])|" + // Klammern

"(?<WS>\\s+)|" + // Whitespace (ignoriert)

"(?<ILLEGAL>.)" // Ungültige Zeichen

);

private final String input;

private final Matcher matcher;

Tokenizer(String input) {

this.input = input;

this.matcher = TOKEN_PATTERN.matcher(input);

}

List<Token> tokenize() {

return matcher.results()

.<Token>mapMulti((result, consumer) -> {

if (result.group("NUM") != null) {

consumer.accept(new Number(

Double.parseDouble(result.group())

));

}

else if (result.group("OP") != null) {

consumer.accept(switch (result.group()) {

case "+" -> Operator.ADD;

case "-" -> Operator.SUB;

case "*" -> Operator.MUL;

case "/" -> Operator.DIV;

case "~" -> Operator.NEG;

case "^" -> Operator.POW;

default -> throw new IllegalStateException();

});

}

else if (result.group("PAREN") != null) {

consumer.accept(switch (result.group()) {

case "(" -> Paren.OPEN;

case ")" -> Paren.CLOSE;

default -> throw new IllegalStateException();

});

}

else if (result.group("VAR") != null) {

consumer.accept(new Variable(result.group()));

}

else if (result.group("FUNC") != null) {

consumer.accept(switch (result.group()) {

case "sin" -> Function.SIN;

case "cos" -> Function.COS;

case "tan" -> Function.TAN;

case String s when s.startsWith("log_") -> {

String base_str = s.substring(4);

try {

double base = Double.parseDouble(base_str);

yield new LogBase(base);

} catch (NumberFormatException nfe) {

yield new Illegal(s);

}

}

case "log" -> Function.LOG;

case "ln" -> Function.LN;

case "sqrt" -> Function.SQRT;

case "exp" -> Function.EXP;

default -> throw new IllegalStateException();

});

}

else if (result.group("CONST") != null) {

consumer.accept(switch (result.group()) {

case "pi" -> Const.PI;

case "e" -> Const.E;

default -> throw new IllegalStateException();

});

}

else if (result.group("ILLEGAL") != null) {

consumer.accept(new Illegal(result.group()));

}

else if (result.group("PAR") != null) {

consumer.accept(new Parameter(result.group()));

}

// Whitespace wird ignoriert

})

.toList();

}

}

record Number(double value) implements Expr {}

record Variable(String name) implements Expr {}

record UnaryOp(Operator op, Expr operand) implements Expr {}

record BinaryOp(Operator op, Expr left, Expr right) implements Expr {}

record FunctionCall(Function function, Expr argument) implements Expr {}

record Constant(Const constant) implements Expr {}

record LogBase(double base, Expr expr) implements Expr {}

record Parameter(String name) implements Expr {}

// (...)

static Expr num(double value) { return new Number(value); }

static Expr var(String name) { return new Variable(name); }

static Expr neg(Expr e) { return new UnaryOp(Operator.NEG, e); }

static Expr add(Expr l, Expr r) { return new BinaryOp(Operator.ADD, l, r); }

static Expr sub(Expr l, Expr r) { return new BinaryOp(Operator.SUB, l, r); }

static Expr mul(Expr l, Expr r) { return new BinaryOp(Operator.MUL, l, r); }

static Expr div(Expr l, Expr r) { return new BinaryOp(Operator.DIV, l, r); }

static Expr pow(Expr l, Expr r) { return new BinaryOp(Operator.POW, l, r); }

static Expr function(Function f, Expr arg) { return new FunctionCall(f, arg); }

static Expr constant(Const c) { return new Constant(c); }

static Expr logBase(double base, Expr arg) { return new LogBase(base, arg); }

static Expr param(String name) { return new Parameter(name); }

Map<String, Double> parameters = new HashMap<>();

// cut out tryEval

default boolean containsVar() {

return switch(this) {

case Expr.Variable v -> true;

case Expr.UnaryOp(Operator op, Expr e) -> e.containsVar();

case Expr.BinaryOp(Operator op, Expr l, Expr r) -> l.containsVar() || r.containsVar();

case Expr.FunctionCall(Function f, Expr arg) -> arg.containsVar();

case Expr.LogBase(double base, Expr arg) -> arg.containsVar();

default -> false;

};

}

default Optional<Double> tryEval() {

return this.containsVar() ? Optional.empty() : Optional.of(eval(0)); // Wert für x ist hier irrelevant, da sowieso keine Variable gegeben ist und das Ergebnis konstant gleich bleibt

}

// cut out tryEval

default boolean containsParameter() {

return switch(this) {

case Expr.UnaryOp(Operator op, Expr e) -> e.containsParameter();

case Expr.BinaryOp(Operator op, Expr l, Expr r) -> l.containsParameter() || r.containsParameter();

case Expr.FunctionCall(Function f, Expr arg) -> arg.containsParameter();

case Expr.LogBase(double base, Expr arg) -> arg.containsParameter();

case Expr.Parameter p -> true;

default -> false;

};

}

default void setParam(String name, double val) {

parameters.put(name, val);

}

private double eval(double x) {

return switch(this) {

case Number n -> n.value();

case Variable v -> x;

case UnaryOp(Operator op, Expr e) -> switch(op) {

case NEG -> -e.eval(x);

default -> throw new UnsupportedOperationException();

};

case BinaryOp(Operator op, Expr l, Expr r) -> switch(op) {

case ADD -> l.eval(x) + r.eval(x);

case SUB -> l.eval(x) - r.eval(x);

case MUL -> l.eval(x) * r.eval(x);

case DIV -> l.eval(x) / r.eval(x);

case POW -> Math.pow(l.eval(x), r.eval(x));

default -> throw new UnsupportedOperationException();

};

case FunctionCall(Function func, Expr arg) -> switch(func) {

case SIN -> Math.sin(arg.eval(x));

case COS -> Math.cos(arg.eval(x));

case TAN -> Math.tan(arg.eval(x));

case LOG -> Math.log10(arg.eval(x));

case LN -> Math.log(arg.eval(x));

case SQRT -> Math.sqrt(arg.eval(x));

case EXP -> Math.exp(arg.eval(x));

};

case Constant(Const c) -> switch(c) {

case PI -> Math.PI;

case E -> Math.E;

};

case LogBase(Double base, Expr arg) -> Math.log(arg.eval(x)) / Math.log(base);

case Parameter p -> {

Double value = parameters.get(p.name());

if (value == null) throw new ArithmeticException("Parameter '" + p.name() + "' not set");

yield value;

}

};

}

private final StringBuilder dot_graph = new StringBuilder();

private final Map<Expr, String> node_names = new HashMap<>();

private int counter = 0;

public String toDot(Expr expr) {

dot_graph.append("digraph AST {\n");

traverse(expr);