TaylorPolyCalc v1.0 Release

#Bibs.:
import sympy as sp
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
from matplotlib.ticker import AutoMinorLocator
import tkinter as tk
from tkinter import ttk, messagebox
#Design (lässt sich evtl. anpassen)
plt.rcParams.update({
    'font.family': 'sans-serif',
    'font.sans-serif': ['Arial'],
    'mathtext.fontset': 'dejavusans',
    'font.size': 14,
    'axes.labelsize': 16,
    'xtick.labelsize': 14,
    'ytick.labelsize': 14,
    'lines.linewidth': 1.5,
    'lines.markersize': 6,
    'figure.dpi': 100,
})



#Verknüpfung x -> x (symbol)
x = sp.Symbol('x')



#Hauptfunktion: holt Eingaben, berechnet Taylor, zeichnet, gibt Polynom in Konsole aus
def plot():
    try:
        #Eingaben aus der GUI
        n = int(eingabe_n.get()) #Ordnung
        f_text = eingabe_f.get() #Fkt.
        x0_text = eingabe_x0.get().strip() #Entwicklungspunkt x_0

        #Enter in "symbolische Ausdrücke" umwandeln
        f = sp.sympify(f_text, locals={'e': sp.E, 'ln': sp.log})
        if x0_text == '':
            x0 = 0 #falls nichts steht - x_0 automatisch = 0
        else:
            x0 = sp.sympify(x0_text, locals={'e': sp.E, 'ln': sp.log}) #sympify: String -> SymPy Ausdruck

        #Ableitungen sammeln (Liste)
        abl = [f] #alle Abl. + Fkt. selbst (da 0. Ordnung)
        akt = f #aktuelle Abl.
        for i in range(1, n+1):
            akt = sp.diff(akt, x)
            akt = sp.simplify(akt) #automatische Vereinfachung jeder akt. Abl.
            abl.append(akt)

        #Bonus: Ableitungenrechner:
        print("Ableitungen:")
        for i in range(len(abl)):
            print(f"{i}. Ableitung: {abl[i]}")

        #Nachdem die Liste voll ist... Taylor-Polynom Summe:
        poly = 0
        for i in range(len(abl)):
            poly += abl[i].subs(x, x0) / sp.factorial(i) * (x - x0)**i # setze x_0 für x in f(x) ein
        poly = sp.simplify(poly) #vereinfachen

        #Ausgabe in Konsole
        print(f"\nT_{n}(x) um x0={x0}:")
        sp.pprint(poly) #pprint <=> pretty print, für die anschauliche Ausgabe
        print() #Leerzeichen für Übersicht

        #Numerische Versionen für Plot
        f_num = sp.lambdify(x, f, 'numpy') #In eine numerische Funktion umwandeln...
        poly_num = sp.lambdify(x, poly, 'numpy')

        #x-Werte: -20..20 für fast "unendliche" Linien auf 2000 Pkt.
        x_vals = np.linspace(-20, 20, 2000)
        y_f = f_num(x_vals)
        y_poly = poly_num(x_vals)

        #Entwicklungspunkt nummerisch... Für irrationale Elemente
        x0_num = float(sp.N(x0))

        #Bereich um x = +-2 um Entwicklungspunkt
        bereich = 5
        #Für y Achse: y = +-10
        bereich_y = 5

        #Plot vorb.
        ax.clear() #falls der Nutzer mehrere Plots betrachten möchte...
        ax.plot(x_vals, y_f, 'k-', linewidth=2, label='$f(x)$')
        ax.plot(x_vals, y_poly, color="#2c7ab6", linestyle='--', linewidth=1.5, label=f'$T_{n}(x)$')
        ax.axvline(x0_num, color='grey', linestyle=':', alpha=0.7)
        ax.plot(x0_num, f_num(x0_num), 'ro', markersize=5)
        ax.set_ylim(-bereich_y, bereich_y)
        ax.set_xlim(x0_num - bereich, x0_num + bereich)

        #Koordinatenachsen & Legende
        ax.axhline(0, color='black', linestyle='-', linewidth=0.8, alpha=0.6)
        ax.axvline(0, color='black', linestyle='-', linewidth=0.8, alpha=0.6)
        ax.set_xlabel('x')
        ax.set_ylabel('f(x)')
        ax.legend(loc='upper right', fontsize=12, framealpha=0.6)

        #Striche für das Ablesen an beiden Achsen:
        ax.xaxis.set_minor_locator(AutoMinorLocator())
        ax.yaxis.set_minor_locator(AutoMinorLocator())

        canvas.draw()
        status.config(text="Fertig! Polynom in Konsole")

#Falls was falsch eingegeben wird...:
    except Exception as fehler:
        messagebox.showerror("Fehler", f"Eingabe oder Berechnung fehlerhaft:\n{fehler}")
        status.config(text="Fehler! Bitte Eingaben prüfen")




#GUI
hauptfenster = tk.Tk()
hauptfenster.title("Taylor-Polynom")
hauptfenster.geometry("1920x1080")

#Infobox mit Hilfen zur Syntax
def zeige_info():
    info_win = tk.Toplevel(hauptfenster)
    info_win.title("Info zur Eingabe")
    info_win.geometry("500x350")
    
    txt = """Erlaubte Funktionen und Schreibweisen:
- Grundrechenarten: +, -, *, /
- Potenzen: x**2 oder x^2
- exp(x) oder e^x, log(x) oder ln(x)
- sin(x), cos(x), tan(x), atan(x)
- sqrt(x), pi, e

Beispiele:
  sin(x)
  ln(1+x)
  atan(x)
  x**3 - 2*x + 1
  e^(-0.3*x) * sin(10*x)

Entwicklungspunkt x0: z.B. 0, 1, pi/2, 2.5"""

    rahmen = ttk.Frame(info_win)
    rahmen.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
    scroll = ttk.Scrollbar(rahmen)
    scroll.pack(side=tk.RIGHT, fill=tk.Y)
    textfeld = tk.Text(rahmen, wrap=tk.WORD, yscrollcommand=scroll.set, font=('Arial', 14))
    textfeld.insert(tk.END, txt.strip())
    textfeld.config(state=tk.DISABLED)
    textfeld.pack(fill=tk.BOTH, expand=True)
    scroll.config(command=textfeld.yview)

#Eingabeleiste
eingabe_rahmen = ttk.Frame(hauptfenster)
eingabe_rahmen.pack(side=tk.TOP, fill=tk.X, padx=10, pady=10)

#Fkt.:
ttk.Label(eingabe_rahmen, text="f(x):", font=('DejaVu Sans', 14)).grid(row=0, column=0, sticky="w")
eingabe_f = ttk.Entry(eingabe_rahmen, width=25, font=('DejaVu Sans', 14))
eingabe_f.grid(row=0, column=1, padx=5)
eingabe_f.insert(0, "sin(x)")

#Ordnung:
ttk.Label(eingabe_rahmen, text="Ordnung n:", font=('DejaVu Sans', 14)).grid(row=0, column=2, padx=(20,0), sticky="w")
eingabe_n = ttk.Entry(eingabe_rahmen, width=8, font=('DejaVu Sans', 14))
eingabe_n.grid(row=0, column=3, padx=5)
eingabe_n.insert(0, "5")

#Entwicklungspunkt:
ttk.Label(eingabe_rahmen, text="x0:", font=('DejaVu Sans', 14)).grid(row=0, column=4, padx=(20,0), sticky="w")
eingabe_x0 = ttk.Entry(eingabe_rahmen, width=8, font=('DejaVu Sans', 14))
eingabe_x0.grid(row=0, column=5, padx=5)
eingabe_x0.insert(0, "0")

#Buttons
ttk.Button(eingabe_rahmen, text="Plot aktualisieren", command=plot).grid(row=0, column=6, padx=15)
ttk.Button(eingabe_rahmen, text="Anleitung", command=zeige_info).grid(row=0, column=7, padx=5)

#Matplotlib-Figur + Toolbar
fig = plt.Figure(figsize=(7, 5), dpi=100)
ax = fig.add_subplot(111)
canvas = FigureCanvasTkAgg(fig, master=hauptfenster)
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)

toolbar_rahmen = ttk.Frame(hauptfenster)
toolbar_rahmen.pack(side=tk.TOP, fill=tk.X)
toolbar = NavigationToolbar2Tk(canvas, toolbar_rahmen)
toolbar.update()

#Statuszeile
status = ttk.Label(hauptfenster, text="Bereit", font=('DejaVu Sans', 14))
status.pack(side=tk.BOTTOM, fill=tk.X, padx=10, pady=5)

#Erster Plot
plot()

hauptfenster.mainloop()