def get_random_logarithmischefunktion(self):
### Funtion vom Typ a*log(x+b,c)+d auch als ln oder 10log ###
if self.logar_spiegelung != "None":
if self.logar_spiegelung == "negativ a":
a = round(uniform(-1, -10), 1)
else:
a = round(uniform(1, 10), 1)
else:
a = 1
if self.logar_vorgeg_log == "None":
if self.logar_spiegelung == "0 < basis < 1":
c = round(random(), 2)
else:
c = round(uniform(2, 10), 1)
if self.trigo_with_x_versch:
b = round(uniform(-5, 5), 1)
else:
b = 0
if self.trigo_with_y_versch:
d = randint(-20, 20)
else:
d = 0
funktion = ""
if a == -1:
funktion += "-"
elif a != 1:
funktion += str(a) + "*"
if self.logar_vorgeg_log == "ln":
funktion += "ln(x"
elif self.logar_vorgeg_log == "log10":
funktion += "log10(x"
else:
funktion += "log(x"
if b != 0:
funktion += vorzeichen_str(b)
if self.logar_vorgeg_log == "None":
funktion += "," + str(c)
funktion += ")"
if d != 0:
funktion += vorzeichen_str(d)
return Funktion(self.parameter, funktion)
def get_random_trigonometrischefunktion(self):
### Funtion vom Typ a*sin(b*(x-c))+d mit sin cos oder tan ###
trigonometrie = choice(["sin", "cos", "tan"])
if self.trigo_vorgeg_trigo in ["sin", "cos", "tan"]:
trigonometrie = self.trigo_vorgeg_trigo
if self.trigo_with_y_streck:
a = round(uniform(-10, 10), 1)
while a == 0:
a = round(uniform(-10, 10), 1)
else:
a = 1
if self.trigo_with_x_streck:
b = randint(-8, 8)
while b == 0:
b = randint(-8, 8)
else:
b = 1
if self.trigo_with_x_versch:
c = round(uniform(-5, 5), 1)
else:
c = 0
if self.trigo_with_y_versch:
d = randint(-20, 20)
else:
d = 0
return_funktion = ""
if a != 1:
return_funktion += str(a) + "*"
return_funktion += trigonometrie + "("
if b != 1:
return_funktion += str(b) + "*("
return_funktion += "x"
if c != 0:
return_funktion += vorzeichen_str(c)
if b != 1:
return_funktion += ")"
return_funktion += ")"
if d != 0:
return_funktion += vorzeichen_str(d)
return Funktion(self.parameter, return_funktion)
def get_random_wurzelfunktion(self):
### Funtion vom Typ a(b(x−c))'(1/2)+d ###
if self.wurzel_with_streck:
a = round(uniform(-10, 10), 1)
else:
a = 1
if self.wurzel_with_x_versch:
c = round(uniform(-10, 10), 1)
else:
c = 0
if self.wurzel_with_y_versch:
d = round(uniform(-10, 10), 1)
else:
d = 0
funktion = ""
if a != 1:
funktion += str(a) + "*"
if c != 0:
funktion += "sqrt(x" + vorzeichen_str(c) + ")"
else:
funktion += "sqrt(x)"
if d != 0:
funktion += vorzeichen_str(d)
return Funktion(self.parameter, funktion)
def make_stammfunktion(parameter,
funktion,
row,
frame,
name,
print_stammfunktion=True,
pdf_writer=None):
pdf = lambda txt: pdf_writer.append(txt
) if pdf_writer is not None else False
tk.Label(frame, text="f(x) = " + funktion.funktion_user_x_ersetztbar).grid(
row=row, column=1)
pdf(["fkt", "f(x) = " + funktion.funktion_user_x_ersetztbar])
stammfunk = Funktion(parameter)
if not "x" in funktion.funktion_user_kurz:
stammfunk.set_funktion(str(funktion.x_einsetzen(0)) + "*x")
tk.Label(frame,
text="Kein x enthalten: f(x) = a -> F(x) = a*x",
fg="blue4").grid(row=row + 1, column=1)
pdf(["fkt", "Kein x enthalten: f(x) = a -> F(x) = a*x"])
tk.Label(frame, text=name + " = " + stammfunk.funktion_user_kurz).grid(
row=row + 2, column=1)
pdf(["fkt", name + " = " + stammfunk.funktion_user_kurz])
elif funktion.is_polynomfunktion:
tk.Label(
frame,
text=
"Polynomfunktion aufleiten nach Formel a*x'b -> (a/(b+1))*x'(b+1)",
fg="blue4").grid(row=row + 1, column=1, sticky=tk.W, columnspan=2)
pdf([
"calc",
"Polynomfunktion aufleiten nach Formel a*x'b -> (a/(b+1))*x'(b+1)"
])
stammfunktion_kurz = ""
stammfunktion_lang = ""
for polynom in funktion.exponenten_array:
if eval(polynom[1]) == -1:
stammfunktion_kurz += vorzeichen_str(
str(eval(polynom[0])) + "*ln(x)")
stammfunktion_lang += vorzeichen_str(
str(eval(polynom[0])) + "*ln(x)")
else:
stammfunktion_lang += " + (" + str(eval(
polynom[0])) + "/(" + str(eval(
polynom[1])) + "+1))*x'(" + str(eval(
polynom[1])) + "+1)"
zaehler, nenner = bruch_kuerzen(eval(polynom[0]),
eval(polynom[1]) + 1)
if nenner == 1:
stammfunktion_kurz += polynom_to_str(
zaehler,
eval(polynom[1]) + 1)
else:
stammfunktion_kurz += polynom_to_str(
"(" + str(zaehler) + "/" + str(nenner) + ")",
eval(polynom[1]) + 1)
stammfunk.set_funktion(stammfunktion_kurz)
tk.Label(frame,
text=name + " = " + stammfunktion_lang).grid(row=row + 2,
column=1)
pdf(["fkt", name + " = " + stammfunktion_lang])
tk.Label(frame, text=name + " = " + stammfunk.funktion_user_kurz).grid(
row=row + 3, column=1)
pdf(["fkt", name + " = " + stammfunk.funktion_user_kurz])
elif funktion.is_trigonometrisch and funktion.trigonometrische_funktion != "tan":
stammfunktion_ende = ""
row_add = 0
if funktion.trigonometrisch_d != 0:
tk.Label(frame, text=" konstante Zahl mit x erweitern",
fg="blue4").grid(row=row + 0, column=2, sticky=tk.W)
pdf(["calc", "konstante Zahl mit x erweitern"])
tk.Label(frame,
text=name + " = " +
funktion.funktion_trigonometrisch_x_ersetzbar + "x").grid(
row=row + 1, column=1)
pdf([
"fkt", name + " = " +
funktion.funktion_trigonometrisch_x_ersetzbar + "x"
])
stammfunktion_ende = vorzeichen_str(funktion.trigonometrisch_d,
mitleerzeichen=True) + "x"
row_add = 1
if funktion.trigonometrische_funktion == "sin":
tk.Label(frame,
text=" Kettenregel sin(v(x)) -> -cos(v(x)) / v'(x)",
fg="blue4").grid(row=row + row_add, column=2, sticky=tk.W)
pdf(["calc", "Kettenregel sin(v(x)) -> -cos(v(x)) / v'(x)"])
tk.Label(
frame,
text=name + " = " + str(funktion.trigonometrisch_a) +
" * -cos(" + n_mal_x_plus_m_to_string(
funktion.trigonometrisch_b, -funktion.trigonometrisch_c) +
") / " + str(funktion.trigonometrisch_b) + " " +
stammfunktion_ende).grid(row=row + row_add + 1, column=1)
pdf([
"fkt", name + " = " + str(funktion.trigonometrisch_a) +
" * -cos(" + n_mal_x_plus_m_to_string(
funktion.trigonometrisch_b, -funktion.trigonometrisch_c) +
") / " + str(funktion.trigonometrisch_b) + " " +
stammfunktion_ende
])
stammfunk = Funktion(
frame.parameter,
str(-funktion.trigonometrisch_a / funktion.trigonometrisch_b) +
" * cos(" + n_mal_x_plus_m_to_string(
funktion.trigonometrisch_b, -funktion.trigonometrisch_c) +
") " + stammfunktion_ende)
elif funktion.trigonometrische_funktion == "cos":
tk.Label(frame,
text=" Kettenregel cos(v(x)) -> sin(v(x)) / v'(x)",
fg="blue4").grid(row=row + row_add, column=2, sticky=tk.W)
pdf(["calc", "Kettenregel cos(v(x)) -> sin(v(x)) / v'(x)"])
tk.Label(
frame,
text=name + " = " + str(funktion.trigonometrisch_a) +
" * sin(" + n_mal_x_plus_m_to_string(
funktion.trigonometrisch_b, -funktion.trigonometrisch_c) +
") / " + str(funktion.trigonometrisch_b) + " " +
stammfunktion_ende).grid(row=row + row_add + 1, column=1)
pdf([
"fkt", name + " = " + str(funktion.trigonometrisch_a) +
" * sin(" + n_mal_x_plus_m_to_string(
funktion.trigonometrisch_b, -funktion.trigonometrisch_c) +
") / " + str(funktion.trigonometrisch_b) + " " +
stammfunktion_ende
])
stammfunk = Funktion(
parameter,
str(funktion.trigonometrisch_a / funktion.trigonometrisch_b) +
" * sin(" + n_mal_x_plus_m_to_string(
funktion.trigonometrisch_b, -funktion.trigonometrisch_c) +
") " + stammfunktion_ende)
tk.Label(frame, text=name + " = " + stammfunk.funktion_user_kurz).grid(
row=row + row_add + 2, column=1)
pdf(["fkt", name + " = " + stammfunk.funktion_user_kurz])
elif funktion.is_wurzel:
stammfunktion_ende = ""
row_add = 0
if funktion.wurzel_d != 0:
tk.Label(frame, text=" konstante Zahl mit x erweitern",
fg="blue4").grid(row=row + 0, column=2, sticky=tk.W)
pdf(["calc", "konstante Zahl mit x erweitern"])
tk.Label(frame,
text=name + " = " + funktion.funktion_wurzel_x_ersetzbar +
"x").grid(row=row + 1, column=1)
pdf([
"fkt",
name + " = " + funktion.funktion_wurzel_x_ersetzbar + "x"
])
stammfunktion_ende = vorzeichen_str(funktion.wurzel_d,
mitleerzeichen=True) + "*x"
row_add = 1
tk.Label(frame,
text=" Kettenregel sqrt(v(x)) -> (2/3)*v(x)'(3/2) / v'(x)",
fg="blue4").grid(row=row + row_add, column=2, sticky=tk.W)
pdf(["calc", "Kettenregel sqrt(v(x)) -> (2/3)*v(x)'(3/2) / v'(x)"])
tk.Label(
frame,
text=name + " = " + str(funktion.wurzel_a) + "* (2/3)*(" +
n_mal_x_plus_m_to_string(funktion.wurzel_b, -funktion.wurzel_c) +
")'(3/2) / " + str(funktion.wurzel_b) + " " +
stammfunktion_ende).grid(row=row + row + 1, column=1, sticky=tk.W)
pdf([
"fkt", name + " = " + str(funktion.wurzel_a) + "* (2/3)*(" +
n_mal_x_plus_m_to_string(funktion.wurzel_b, -funktion.wurzel_c) +
")'(3/2) / " + str(funktion.wurzel_b) + " " + stammfunktion_ende
])
bruch = bruch_kuerzen(2 * funktion.wurzel_a, 3 * funktion.wurzel_b)
if bruch[1] != 1:
stammfunk = Funktion(
parameter,
"(" + str(bruch[0]) + "*(" + n_mal_x_plus_m_to_string(
funktion.wurzel_b, -funktion.wurzel_c) + ")'(3/2) ) /" +
str(bruch[1]) + stammfunktion_ende)
else:
stammfunk = Funktion(
parameter,
str(bruch[0]) + "*(" + n_mal_x_plus_m_to_string(
funktion.wurzel_b, -funktion.wurzel_c) + ")'(3/2)" +
stammfunktion_ende)
else:
could_be_solved = True
try:
loesung = sympy.integrate(funktion.funktion_sympy_readable,
sympy.Symbol('x'))
stammfunk = Funktion(parameter)
funktion_erkannt = stammfunk.set_funktion(
sympy.printing.sstr(loesung).replace("**", "'"))
if funktion_erkannt:
tk.Label(frame,
text=name + " = " +
stammfunk.funktion_user_kurz).grid(row=row + 1,
column=1)
pdf(["fkt", name + " = " + stammfunk.funktion_user_kurz])
else:
my_font = font.Font(family="Courier New")
style = ttk.Style()
style.configure("Fixed.TLabel", font=my_font)
could_be_solved = False
tk.Label(frame,
text="Vielleicht hilft das: " +
sympy.sstr(loesung).replace("**", "'")).grid(
row=row + 2, column=0, columnspan=2, sticky=tk.W)
[
ttk.Label(frame, text=line,
style="Fixed.TLabel").grid(row=row + count + 3,
column=0,
columnspan=2,
sticky=tk.W)
for count, line in enumerate(
sympy.pretty(loesung).split("\n"))
]
except Exception:
could_be_solved = False
if not could_be_solved:
tk.Label(frame,
text="Stammfunktion konnte nicht erstellt werden",
fg="red").grid(row=row + 1,
column=0,
columnspan=2,
sticky=tk.W)
pdf(["noerg", "Stammfunktion konnte nicht erstellt werden"])
return None, row + 1
if print_stammfunktion:
tk.Label(frame,
text="Stammfunktion: " + name + " = " +
stammfunk.funktion_user_kurz,
fg="green4").grid(row=row + 4,
column=0,
sticky=tk.W,
columnspan=2)
pdf([
"erg",
"Stammfunktion: " + name + " = " + stammfunk.funktion_user_kurz
])
return stammfunk, row + 5
def ableiten(self, davor_abgeleitete_funktion, num_ableitung, row,
pdf_writer):
pdf = lambda txt: pdf_writer.append(
txt) if pdf_writer is not None else False
ableitungsfunktion = None
funktionsname = "f"
for i in range(num_ableitung):
funktionsname += "'"
funktionsname_davor = funktionsname[:-1] + "(x)"
funktionsname += "(x)"
tk.Label(self, text=str(num_ableitung) + ". Ableitung:",
fg="blue4").grid(row=row + 1,
column=0,
columnspan=2,
sticky=tk.W)
pdf(["title", str(num_ableitung) + ". Ableitung:"])
tk.Label(self,
text=funktionsname_davor + " = " +
davor_abgeleitete_funktion.funktion_user_x_ersetztbar).grid(
row=row + 2, column=1)
row = row + 2
if not "x" in davor_abgeleitete_funktion.funktion_user_x_ersetztbar:
ableitungsfunktion = Funktion(self.parameter, "0")
tk.Label(self, text="Kein x enthalten:",
fg="blue2").grid(row=row + 1,
column=0,
columnspan=2,
sticky=tk.W)
pdf(["calc", "Kein x enthalten:"])
tk.Label(self, text=funktionsname + " = 0").grid(row=row + 2,
column=1)
pdf(["fkt", funktionsname + " = 0"])
tk.Label(self,
text=str(num_ableitung) + ". Ableitung: " +
funktionsname + " = 0",
fg="green4").grid(row=row + 3, column=0, sticky=tk.W)
pdf([
"erg",
str(num_ableitung) + ". Ableitung: " + funktionsname + " = 0"
])
row = row + 3
elif davor_abgeleitete_funktion.is_polynomfunktion:
exponenten = davor_abgeleitete_funktion.exponenten_array
tk.Label(self, text="In Exponentialform bringen:",
fg="blue2").grid(row=row + 1,
column=0,
columnspan=2,
sticky=tk.W)
pdf(["calc", "In Exponentialform bringen:"])
tk.Label(
self,
text=funktionsname_davor + " = " +
davor_abgeleitete_funktion.funktion_polynom_x_ersetzbar).grid(
row=row + 2, column=1)
pdf([
"fkt", funktionsname_davor + " = " +
davor_abgeleitete_funktion.funktion_polynom_x_ersetzbar
])
tk.Label(self,
text="Ableiten nach Regel ax'b -> (a*b)*x'(b-1):",
fg="blue2").grid(row=row + 3,
column=0,
columnspan=2,
sticky=tk.W)
pdf(["calc", "Ableiten nach Regel ax'b -> (a*b)*x'(b-1):"])
row = row + 3
neue_exponenten = []
neue_exponenten_kurz = []
for exponent in exponenten:
neue_exponenten.append([
"(" + exponent[0] + "*" + exponent[1] + ")",
"(" + exponent[1] + "-1)"
])
p = self.parameter.wert
basis_wert = eval(
davor_abgeleitete_funktion.funktion_to_computer_readable(
self.__funktion.funktion_verschoenern("((" +
exponent[0] +
")*" +
exponent[1] +
")")))
expo_wert = eval(
self.__funktion.funktion_to_computer_readable(
self.__funktion.funktion_verschoenern("((" +
exponent[1] +
")-1)")))
neue_exponenten_kurz.append([basis_wert, expo_wert])
poly_funktion = ""
poly_funktion_kurz = ""
for poly_num in range(0, len(neue_exponenten)):
poly_funktion += vorzeichen_str(
neue_exponenten[poly_num][0] + "*x'" +
neue_exponenten[poly_num][1], True)
poly_funktion_kurz += polynom_array_to_str(
neue_exponenten_kurz[poly_num])
ableitungsfunktion = Funktion(self.parameter, poly_funktion_kurz)
tk.Label(self, text=funktionsname + " = " + poly_funktion).grid(
row=row + 1, column=1)
pdf(["fkt", funktionsname + " = " + poly_funktion])
tk.Label(self,
text=funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz).grid(row=row + 2,
column=1)
pdf([
"fkt",
funktionsname + " = " + ableitungsfunktion.funktion_user_kurz
])
tk.Label(self,
text=str(num_ableitung) + ". Ableitung: " +
funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz,
fg="green4").grid(row=row + 3, column=0, sticky=tk.W)
pdf([
"erg",
str(num_ableitung) + ". Ableitung: " + funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz
])
row = row + 3
elif davor_abgeleitete_funktion.is_trigonometrisch:
if davor_abgeleitete_funktion.trigonometrisch_d != 0:
tk.Label(self,
text=" konstante Zahl fällt weg, da kein x enthalten",
fg="blue2").grid(row=row, column=2, sticky=tk.W)
pdf(["calc", "konstante Zahl fällt weg, da kein x enthalten"])
tk.Label(self,
text=funktionsname + " = " +
str(davor_abgeleitete_funktion.trigonometrisch_a) +
" * " +
davor_abgeleitete_funktion.trigonometrische_funktion +
"(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.trigonometrisch_b,
-davor_abgeleitete_funktion.trigonometrisch_c) +
")").grid(row=row + 1, column=1)
pdf([
"fkt", funktionsname + " = " +
str(davor_abgeleitete_funktion.trigonometrisch_a) + " * " +
davor_abgeleitete_funktion.trigonometrische_funktion +
"(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.trigonometrisch_b,
-davor_abgeleitete_funktion.trigonometrisch_c) + ")"
])
row = row + 1
if davor_abgeleitete_funktion.trigonometrische_funktion == "cos":
tk.Label(
self,
text="Nach Kettenregel " +
davor_abgeleitete_funktion.trigonometrische_funktion +
"(u(x)) -> -sin(u(x)) * u'(x), Vorfaktor bleibt erhalten",
fg="blue2").grid(row=row + 1, column=1)
pdf([
"calc", "Nach Kettenregel " +
davor_abgeleitete_funktion.trigonometrische_funktion +
"(u(x)) -> -sin(u(x)) * u'(x), Vorfaktor bleibt erhalten"
])
tk.Label(
self,
text=funktionsname + " = " +
str(davor_abgeleitete_funktion.trigonometrisch_a) +
" * -sin(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.trigonometrisch_b,
-davor_abgeleitete_funktion.trigonometrisch_c) +
") * " +
str(davor_abgeleitete_funktion.trigonometrisch_b)).grid(
row=row + 2, column=1)
pdf([
"fkt", funktionsname + " = " +
str(davor_abgeleitete_funktion.trigonometrisch_a) +
" * -sin(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.trigonometrisch_b,
-davor_abgeleitete_funktion.trigonometrisch_c) +
") * " + str(davor_abgeleitete_funktion.trigonometrisch_b)
])
ableitungsfunktion = Funktion(
self.parameter,
str(-1 * davor_abgeleitete_funktion.trigonometrisch_a *
davor_abgeleitete_funktion.trigonometrisch_b) +
" * sin(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.trigonometrisch_b,
-davor_abgeleitete_funktion.trigonometrisch_c) + ")")
elif davor_abgeleitete_funktion.trigonometrische_funktion == "sin":
tk.Label(
self,
text="Nach Kettenregel " +
davor_abgeleitete_funktion.trigonometrische_funktion +
"(u(x)) -> cos(u(x)) * u'(x), Vorfaktor bleibt erhalten",
fg="blue2").grid(row=row + 1, column=1)
pdf([
"calc", "Nach Kettenregel " +
davor_abgeleitete_funktion.trigonometrische_funktion +
"(u(x)) -> cos(u(x)) * u'(x), Vorfaktor bleibt erhalten"
])
tk.Label(
self,
text=funktionsname + " = " +
str(davor_abgeleitete_funktion.trigonometrisch_a) +
" * cos(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.trigonometrisch_b,
-davor_abgeleitete_funktion.trigonometrisch_c) +
") * " +
str(davor_abgeleitete_funktion.trigonometrisch_b)).grid(
row=row + 2, column=1)
pdf([
"fkt", funktionsname + " = " +
str(davor_abgeleitete_funktion.trigonometrisch_a) +
" * cos(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.trigonometrisch_b,
-davor_abgeleitete_funktion.trigonometrisch_c) +
") * " + str(davor_abgeleitete_funktion.trigonometrisch_b)
])
ableitungsfunktion = Funktion(
self.parameter,
str(davor_abgeleitete_funktion.trigonometrisch_a *
davor_abgeleitete_funktion.trigonometrisch_b) +
" * cos(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.trigonometrisch_b,
-davor_abgeleitete_funktion.trigonometrisch_c) + ")")
elif davor_abgeleitete_funktion.trigonometrische_funktion == "tan":
tk.Label(
self,
text=
" tan() -> 1/cos()² mit Kettenregel tan(v(x)) -> v'(x)/(cos(x)²",
fg="blue2").grid(row=row, column=2, sticky=tk.W)
pdf([
"calc",
"tan() -> 1/cos()² mit Kettenregel tan(v(x)) -> v'(x)/(cos(x)²"
])
tk.Label(self,
text="F(x) = " +
str(self.__funktion.trigonometrisch_a) + " * " +
str(self.__funktion.trigonometrisch_b) + " / cos(" +
n_mal_x_plus_m_to_string(
self.__funktion.trigonometrisch_b,
-self.__funktion.trigonometrisch_c) + ")'2").grid(
row=row + 1, column=1)
pdf([
"fkt", "F(x) = " + str(self.__funktion.trigonometrisch_a) +
" * " + str(self.__funktion.trigonometrisch_b) +
" / cos(" + n_mal_x_plus_m_to_string(
self.__funktion.trigonometrisch_b,
-self.__funktion.trigonometrisch_c) + ")'2"
])
ableitungsfunktion = Funktion(
self.parameter,
str(davor_abgeleitete_funktion.trigonometrisch_a *
davor_abgeleitete_funktion.trigonometrisch_b) +
" / cos(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.trigonometrisch_b,
-davor_abgeleitete_funktion.trigonometrisch_c) + ")'2")
tk.Label(self,
text=funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz).grid(row=row + 3,
column=1)
pdf([
"fkt",
funktionsname + " = " + ableitungsfunktion.funktion_user_kurz
])
tk.Label(self,
text=str(num_ableitung) + ". Ableitung: " +
funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz,
fg="green4").grid(row=row + 4, column=0, sticky=tk.W)
pdf([
"erg",
str(num_ableitung) + ". Ableitung: " + funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz
])
row = row + 4
elif davor_abgeleitete_funktion.is_wurzel:
if davor_abgeleitete_funktion.wurzel_d != 0:
tk.Label(self,
text=" konstante Zahl fällt weg, da kein x enthalten",
fg="blue2").grid(row=row, column=2, sticky=tk.W)
pdf(["calc", "konstante Zahl fällt weg, da kein x enthalten"])
tk.Label(self,
text=funktionsname + " = " +
str(davor_abgeleitete_funktion.wurzel_a) +
" * sqrt(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.wurzel_b,
-davor_abgeleitete_funktion.wurzel_c) + ")").grid(
row=row + 1, column=1)
pdf([
"fkt", funktionsname + " = " +
str(davor_abgeleitete_funktion.wurzel_a) + " * sqrt(" +
n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.wurzel_b,
-davor_abgeleitete_funktion.wurzel_c) + ")"
])
row = row + 1
tk.Label(self, text=" Wurzel lösen nach √x -> 1/(2√x)",
fg="blue2").grid(row=row, column=2, sticky=tk.W)
pdf(["calc", "Wurzel lösen nach √x -> 1/(2√x)"])
tk.Label(self,
text=funktionsname + " = " +
str(davor_abgeleitete_funktion.wurzel_a) +
" * 1/(2*sqrt(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.wurzel_b,
-davor_abgeleitete_funktion.wurzel_c) + "))").grid(
row=row, column=1)
pdf([
"fkt", funktionsname + " = " +
str(davor_abgeleitete_funktion.wurzel_a) +
" * 1/(2*sqrt(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.wurzel_b,
-davor_abgeleitete_funktion.wurzel_c) + "))"
])
tk.Label(
self,
text=
" Nach Kettenregel auch innere Funktion ableiten und multiplizieren",
fg="blue2").grid(row=row + 1, column=2, sticky=tk.W)
pdf([
"calc",
"Nach Kettenregel auch innere Funktion ableiten und multiplizieren"
])
tk.Label(self,
text=funktionsname + " = " +
str(davor_abgeleitete_funktion.wurzel_a) +
" * 1/(2*sqrt(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.wurzel_b,
-davor_abgeleitete_funktion.wurzel_c) + ")) * " +
str(davor_abgeleitete_funktion.wurzel_b)).grid(row=row +
1,
column=1)
pdf([
"fkt", funktionsname + " = " +
str(davor_abgeleitete_funktion.wurzel_a) + " * 1/(2*sqrt(" +
n_mal_x_plus_m_to_string(davor_abgeleitete_funktion.wurzel_b,
-davor_abgeleitete_funktion.wurzel_c)
+ ")) * " + str(davor_abgeleitete_funktion.wurzel_b)
])
bruch = bruch_kuerzen(
davor_abgeleitete_funktion.wurzel_a *
davor_abgeleitete_funktion.wurzel_b, 2)
ableitungsfunktion = Funktion(
self.parameter,
str(bruch[0]) + "/(" + str(bruch[1]) +
"*sqrt(" + n_mal_x_plus_m_to_string(
davor_abgeleitete_funktion.wurzel_b,
-davor_abgeleitete_funktion.wurzel_c) + "))")
tk.Label(self,
text=funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz).grid(row=row + 2,
column=1)
pdf([
"fkt",
funktionsname + " = " + ableitungsfunktion.funktion_user_kurz
])
tk.Label(self,
text=str(num_ableitung) + ". Ableitung: " +
funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz,
fg="green4").grid(row=row + 3, column=0, sticky=tk.W)
pdf([
"erg",
str(num_ableitung) + ". Ableitung: " + funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz
])
row = row + 3
else:
could_be_solved = True
try:
loesung = sympy.diff(
davor_abgeleitete_funktion.funktion_sympy_readable,
sympy.Symbol('x'), 1)
ableitungsfunktion = Funktion(self.parameter)
funktion_erkannt = ableitungsfunktion.set_funktion(
sympy.printing.sstr(loesung).replace("**", "'"))
if funktion_erkannt:
tk.Label(self,
text=funktionsname + "= " +
ableitungsfunktion.funktion_user_kurz).grid(
row=row + 1, column=1)
pdf([
"fkt", funktionsname + "= " +
ableitungsfunktion.funktion_user_kurz
])
tk.Label(self,
text=str(num_ableitung) + ". Ableitung: " +
funktionsname + " = " +
ableitungsfunktion.funktion_user_kurz,
fg="green4").grid(row=row + 2,
column=0,
sticky=tk.W)
pdf([
"erg",
str(num_ableitung) + ". Ableitung: " + funktionsname +
" = " + ableitungsfunktion.funktion_user_kurz
])
row = row + 2
else:
my_font = font.Font(family="Courier New")
style = ttk.Style()
style.configure("Fixed.TLabel", font=my_font)
could_be_solved = False
tk.Label(self,
text="Vielleicht hilft das: " +
sympy.sstr(loesung).replace("**", "'")).grid(
row=2, column=0, columnspan=2, sticky=tk.W)
[
ttk.Label(self, text=line,
style="Fixed.TLabel").grid(row=count + 3,
column=0,
columnspan=2,
sticky=tk.W)
for count, line in enumerate(
sympy.pretty(loesung).split("\n"))
]
except Exception:
could_be_solved = False
if not could_be_solved:
ableitungsfunktion = None
tk.Label(self,
text="Ableitung konnte nicht erstellt werden",
fg="red").grid(row=row + 1,
column=0,
columnspan=2,
sticky=tk.W)
pdf(["noerg", "Ableitung konnte nicht erstellt werden"])
row = row + 3
if ableitungsfunktion != None:
return ableitungsfunktion, row
else:
return None, row
def integral_berechnen(self):
self.pdf_writer.integral_texte = []
pdf = lambda txt: self.pdf_writer.integral_texte.append(
txt) if self.pdf_writer is not None else False
if self.zwischen_graphen and len(
self.differenz_stammfunktion.funktionen) >= 1:
stammfunktion = self.differenz_stammfunktion.funktionen[1].funktion
pdf([
"title", "Fläche zwischen den Funktionen zwischen Stelle x=" +
str(self.x_start.get()) + " und x=" + str(self.x_ende.get())
])
elif self.rotationskoerper and self.__funktion != None:
try:
pdf([
"title", "Rotationskörper um X-Achse zwischen Stelle x=" +
str(self.x_start.get()) + " und x=" +
str(self.x_ende.get())
])
pdf([
"calc", "Funktion quadrieren und dann Stammfunktion bilden"
])
tk.Label(self,
text="Funktion f(x) = " +
self.__funktion.funktion_user_kurz).grid(row=2,
column=1)
pdf([
"fkt",
"Funktion f(x) = " + self.__funktion.funktion_user_kurz
])
qudrat_funktion = Funktion(
self.parameter,
"(" + self.__funktion.funktion_sympy_readable + ")^2")
tk.Label(self,
text="(f(x))² = " +
qudrat_funktion.funktion_user_kurz).grid(row=3,
column=1)
pdf(["fkt", "(f(x))² = " + qudrat_funktion.funktion_user_kurz])
loesung = sympy.integrate(
qudrat_funktion.funktion_sympy_readable, sympy.Symbol('x'))
stammfunktion = Funktion(self.parameter)
funktion_erkannt = stammfunktion.set_funktion(
sympy.printing.sstr(loesung).replace("**", "'"))
if not funktion_erkannt:
tk.Label(self,
text="Stammfunktion konnte nicht erstellt werden",
fg="red").grid(row=2, column=1)
pdf([
"noerg", "Stammfunktion konnte nicht erstellt werden"
])
return
except Exception:
tk.Label(self,
text="Stammfunktion konnte nicht erstellt werden",
fg="red").grid(row=2, column=1)
pdf(["noerg", "Stammfunktion konnte nicht erstellt werden"])
return
elif self.zwischen_graphen == False and self.rotationskoerper == False and len(
self.stammfunktion.funktionen) >= 1:
pdf([
"title", "Fläche zwischen Stelle x=" +
str(self.x_start.get()) + " und x=" + str(self.x_ende.get())
])
stammfunktion = self.stammfunktion.funktionen[0].funktion
else:
tk.Label(self, text="Keine Stammfunktion gefunden",
fg="red").grid(row=2, column=1)
pdf(["noerg", "Stammfunktion konnte nicht erstellt werden"])
return
tk.Label(self,
text="Stammfunktion: " + stammfunktion.funktion_user_kurz,
fg="blue4").grid(row=4, column=1)
pdf(["fkt", "Stammfunktion: " + stammfunktion.funktion_user_kurz])
tk.Label(self,
text="1. Beide Werte in Stammfunktion einsetzen:",
fg="blue2").grid(row=5, column=0, sticky=tk.W, columnspan=2)
pdf(["calc", "1. Beide Werte in Stammfunktion einsetzen:"])
erster_wert = stammfunktion.x_einsetzen(self.x_start.get())
zweiter_wert = stammfunktion.x_einsetzen(self.x_ende.get())
tk.Label(self,
text="F(" + str(self.x_start.get()) + ") = " +
str(erster_wert)).grid(row=6, column=1, sticky=tk.W)
pdf([
"fkt", "F(" + str(self.x_start.get()) + ") = " + str(erster_wert)
])
tk.Label(self,
text="F(" + str(self.x_ende.get()) + ") = " +
str(zweiter_wert)).grid(row=7, column=1, sticky=tk.W)
pdf([
"fkt", "F(" + str(self.x_ende.get()) + ") = " + str(zweiter_wert)
])
if erster_wert == "nicht definiert" or zweiter_wert == "nicht definiert":
tk.Label(
self,
text=
"Kein Ergebnis, da eine nicht definiert Zahl in Ergebnissen",
fg="red").grid(row=8, column=0, sticky=tk.W, columnspan=2)
pdf([
"noerg",
"Kein Ergebnis, da eine nicht definiert Zahl in Ergebnissen"
])
elif (self.nullstellen != None and self.zwischen_graphen
== False) or (self.differenz_stammfunktion != None
and self.zwischen_graphen):
# nach Nullstellen der Funktion zwischen den beiden Punkten suchen
nullstellen_dazwischen = []
if self.zwischen_graphen:
nst = self.differenz_stammfunktion.punkte
else:
nst = self.nullstellen.punkte
for punkt in nst:
if isinstance(punkt, Wiederholender_Punkt):
wieder_punkte = punkt.get_koordinaten_from_to(
self.x_start.get(), self.x_ende.get())
for wieder_punkt in wieder_punkte:
nullstellen_dazwischen.append(
Punkt(wieder_punkt[0], wieder_punkt[1], "nst"))
else:
if self.x_start.get() < punkt.x < self.x_ende.get():
nullstellen_dazwischen.append(punkt)
if len(nullstellen_dazwischen) >= 1 and self.achte_auf_nullstellen:
tk.Label(
self,
text=
"!! ACHTUNG Wenn nicht gefundene Nullstellen zwischen den Punkten liegen werden die Flächen unter dem Graph negativ gesehen und im Ergebnis abgezogen",
fg="red").grid(row=8, column=0, sticky=tk.W, columnspan=2)
tk.Label(self,
text="2. Nullstellen zwischen Werten finden",
fg="blue2").grid(row=9,
column=0,
sticky=tk.W,
columnspan=2)
pdf(["calc", "2. Nullstellen zwischen Werten finden"])
nst_text = "Nulstellen: "
for punkt in nullstellen_dazwischen:
nst_text += str(punkt) + ", "
nst_text = nst_text[:-2]
tk.Label(self, text=nst_text).grid(row=10,
column=1,
sticky=tk.W)
pdf(["fkt", nst_text])
tk.Label(self,
text="3. Auch Nullstellen einsetzten",
fg="blue2").grid(row=11,
column=0,
sticky=tk.W,
columnspan=2)
pdf(["calc", "3. Auch Nullstellen einsetzten"])
werte_nullstellen = []
for count, punkt in enumerate(nullstellen_dazwischen):
wert = stammfunktion.x_einsetzen(punkt.x)
werte_nullstellen.append(wert)
tk.Label(self,
text="F(" + str(punkt.x) + ") = " +
str(wert)).grid(row=12 + count,
column=1,
sticky=tk.W)
pdf(["fkt", "F(" + str(punkt.x) + ") = " + str(wert)])
row = 12 + count
werte_nullstellen.insert(0, erster_wert)
werte_nullstellen.insert(len(werte_nullstellen), zweiter_wert)
if "nicht definiert" in werte_nullstellen:
tk.Label(
self,
text=
"Ergebnis kann nicht berechnet werden, da eine nicht definiert Zahl in den Ergebnissen ist",
fg="red").grid(row=9,
column=0,
sticky=tk.W,
columnspan=2)
pdf([
"noerg",
"Ergebnis kann nicht berechnet werden, da eine nicht definiert Zahl in den Ergebnissen ist"
])
else:
# Differenzen berechnen
tk.Label(
self,
text=
"4. Differenz zwischen den errechneten Werten finden:",
fg="blue2").grid(row=row + 1,
column=0,
sticky=tk.W,
columnspan=2)
pdf([
"calc",
"4. Differenz zwischen den errechneten Werten finden:"
])
ergbnis_teile = []
for punkt_num in range(len(werte_nullstellen) - 1):
teil_erg = abs(werte_nullstellen[punkt_num + 1] -
werte_nullstellen[punkt_num])
ergbnis_teile.append(teil_erg)
tk.Label(
self,
text="| " + " " +
str(werte_nullstellen[punkt_num + 1]) + " " +
vorzeichen_str(-werte_nullstellen[punkt_num]) +
" | = " + str(teil_erg)).grid(row=row + 2 +
punkt_num,
column=1,
sticky=tk.W)
pdf([
"fkt", "| " + " " +
str(werte_nullstellen[punkt_num + 1]) + " " +
vorzeichen_str(-werte_nullstellen[punkt_num]) +
" | = " + str(teil_erg)
])
row = row + 2 + punkt_num
erg = math.fsum(ergbnis_teile)
tk.Label(self,
text="5. Ergebnisse zusammenzählen:",
fg="blue2").grid(row=row + 1,
column=0,
sticky=tk.W,
columnspan=2)
pdf(["calc", "5. Ergebnisse zusammenzählen:"])
tk.Label(self, text="Fläche = " + str(erg),
fg="green4").grid(row=row + 2,
column=1,
sticky=tk.W)
pdf(["erg", "Fläche = " + str(erg)])
row += 2
else:
if self.achte_auf_nullstellen:
tk.Label(
self,
text=
"!! ACHTUNG Keine Nullstellen gefunden. Flächen unter dem Graph werden negativ gesehen und im Ergebnis abgezogen",
fg="red").grid(row=8,
column=0,
sticky=tk.W,
columnspan=2)
# Differenz berechnen
tk.Label(self,
text="2. Differenz der beiden Werte finden:",
fg="blue2").grid(row=9,
column=0,
sticky=tk.W,
columnspan=2)
pdf(["calc", "2. Differenz der beiden Werte finden:"])
erg = zweiter_wert - erster_wert
tk.Label(self,
text="| " + str(zweiter_wert) + " " +
vorzeichen_str(-erster_wert) + " | = " +
str(erg)).grid(row=10, column=1, sticky=tk.W)
pdf([
"fkt", "| " + str(zweiter_wert) + " " +
vorzeichen_str(-erster_wert) + " | = " + str(erg)
])
if self.rotationskoerper:
tk.Label(self,
text="Volumen = pi*" + str(erg),
fg="green4").grid(row=11, column=1, sticky=tk.W)
pdf(["fkt", "Volumen = pi*" + str(erg)])
erg *= math.pi
tk.Label(self, text="Volumen = " + str(erg),
fg="green4").grid(row=12, column=1, sticky=tk.W)
pdf(["erg", "Volumen = " + str(erg)])
else:
tk.Label(self, text="Fläche = " + str(erg),
fg="green4").grid(row=11, column=1, sticky=tk.W)
pdf(["erg", "Fläche = " + str(erg)])
row = 12
if self.zwischen_graphen == False and self.rotationskoerper == False:
try:
mittelwert = erg / (self.x_ende.get() - self.x_start.get())
tk.Label(self, text="Mittelwert:",
fg="blue4").grid(row=row + 1,
column=0,
sticky=tk.W,
columnspan=2)
pdf(["title", "Mittelwert:"])
tk.Label(self, text="m = Fläche / (ende-start)").grid(
row=row + 2, column=1, sticky=tk.W)
pdf(["calc", "m = Fläche / (ende-start)"])
tk.Label(self,
text="m = " + str(erg) + " / (" +
str(self.x_ende.get()) +
vorzeichen_str(-self.x_start.get()) + ") = " +
str(mittelwert)).grid(row=row + 3,
column=1,
sticky=tk.W)
pdf([
"fkt",
"m = " + str(erg) + " / (" + str(self.x_ende.get()) +
vorzeichen_str(-self.x_start.get()) + ") = " +
str(mittelwert)
])
tk.Label(self,
text="Mittelwert = " + str(mittelwert),
fg="green4").grid(row=row + 4,
column=1,
sticky=tk.W)
pdf(["erg", "Mittelwert = " + str(mittelwert)])
self.funktionen.append(
Graph(Funktion(self.parameter, str(mittelwert)),
"#333344", "dunkelgrau", "Mittelwert"))
except Exception:
pass
def createWidgets(self):
for widget in self.winfo_children():
widget.destroy()
if self.__funktion != None:
self.pdf_writer.normale_texte = []
self.pdf_writer.tangente_texte = []
pdf_norm = lambda txt: self.pdf_writer.normale_texte.append(
txt) if self.pdf_writer is not None else False
pdf_tang = lambda txt: self.pdf_writer.tangente_texte.append(
txt) if self.pdf_writer is not None else False
self.funktionen = []
self.x_regler = tk.Scale(self,
from_=-100,
to=100,
orient=tk.HORIZONTAL,
variable=self.x_wert)
self.x_regler.config(command=self.scrollbar_bewegt)
self.x_regler.grid(row=0, column=0, sticky=tk.NSEW)
self.spinbox = tk.Spinbox(self,
from_=-100,
to=100,
textvariable=self.x_wert)
self.spinbox.config(command=self.scrollbar_bewegt)
self.spinbox.grid(row=0, column=1, sticky=tk.W)
pdf_norm(
["title", "Normale an Stelle x = " + str(self.x_wert.get())])
pdf_tang(
["title", "Tangente an Stelle x = " + str(self.x_wert.get())])
tk.Label(self,
text=str(self.x_wert.get()) +
" in Gleichungen einsetzten",
fg="blue2").grid(row=1, column=0, sticky=tk.W)
pdf_norm([
"calc",
str(self.x_wert.get()) + " in Gleichungen einsetzten"
])
pdf_tang([
"calc",
str(self.x_wert.get()) + " in Gleichungen einsetzten"
])
tk.Label(
self,
text="f(" + str(self.x_wert.get()) + ") = " +
self.__funktion.funktion_x_eingesetzt(self.x_wert.get())).grid(
row=2, column=1)
pdf_norm([
"fkt", "f(" + str(self.x_wert.get()) + ") = " +
self.__funktion.funktion_x_eingesetzt(self.x_wert.get())
])
pdf_tang([
"fkt", "f(" + str(self.x_wert.get()) + ") = " +
self.__funktion.funktion_x_eingesetzt(self.x_wert.get())
])
erg_normale_funktion = self.__funktion.x_einsetzen(
self.x_wert.get())
tk.Label(self,
text="f(" + str(self.x_wert.get()) + ") = " +
str(erg_normale_funktion)).grid(row=3, column=1)
pdf_norm([
"fkt", "f(" + str(self.x_wert.get()) + ") = " +
str(erg_normale_funktion)
])
pdf_tang([
"fkt", "f(" + str(self.x_wert.get()) + ") = " +
str(erg_normale_funktion)
])
if len(self.ableitung.funktionen
) > 0 and self.ableitung.funktionen[0].funktion != None:
ableitung = self.ableitung.funktionen[0].funktion
erg_ableitung = ableitung.x_einsetzen(self.x_wert.get())
tk.Label(
self,
text="f'(" + str(self.x_wert.get()) + ") = " +
ableitung.funktion_x_eingesetzt(self.x_wert.get())).grid(
row=4, column=1)
pdf_norm([
"fkt", "f'(" + str(self.x_wert.get()) + ") = " +
ableitung.funktion_x_eingesetzt(self.x_wert.get())
])
pdf_tang([
"fkt", "f'(" + str(self.x_wert.get()) + ") = " +
ableitung.funktion_x_eingesetzt(self.x_wert.get())
])
tk.Label(self,
text="f'(" + str(self.x_wert.get()) + ") = " +
str(erg_ableitung)).grid(row=5, column=1)
pdf_norm([
"fkt", "f'(" + str(self.x_wert.get()) + ") = " +
str(erg_ableitung)
])
pdf_tang([
"fkt", "f'(" + str(self.x_wert.get()) + ") = " +
str(erg_ableitung)
])
else:
tk.Label(self, text="f'(x) nicht bekannt",
fg="red").grid(row=4, column=1)
pdf_norm(["noerg", "f'(x) nicht bekannt"])
pdf_tang(["noerg", "f'(x) nicht bekannt"])
erg_ableitung = "nicht definiert"
tk.Label(self,
text="Tangente nach Formel t(x) = f'(x0)*(x-x0)+f(x0):",
fg="blue2").grid(row=6, column=0, sticky=tk.W)
pdf_tang(
["calc", "Tangente nach Formel t(x) = f'(x0)*(x-x0)+f(x0):"])
tk.Label(
self,
text="Normale nach Formel n(x) = (-1/f'(x0))*(x-x0)+f(x0):",
fg="blue2").grid(row=8, column=0, sticky=tk.W)
pdf_norm([
"calc", "Normale nach Formel n(x) = (-1/f'(x0))*(x-x0)+f(x0):"
])
if erg_ableitung != "nicht definiert" and erg_normale_funktion != "nicht definiert":
# normalengleichung zusammenbasteln
funktionsterm = ""
if erg_ableitung != 0:
funktionsterm += str(erg_ableitung)
if self.x_wert.get() != 0:
funktionsterm += " * (x" + vorzeichen_str(
self.x_wert.get() * -1) + ") "
else:
funktionsterm += " * x "
if erg_normale_funktion != 0:
funktionsterm += vorzeichen_str(erg_normale_funktion)
if funktionsterm == "":
funktionsterm = "0"
t = Funktion(self.parameter, funktionsterm)
graph_t = Graph(t, "#FFBB00", "dunkelgelb", "t(x)")
self.funktionen.append(graph_t)
tk.Label(self,
text="t(x) = " + t.funktion_user_kurz,
fg="green4").grid(row=7, column=1)
pdf_tang(["erg", "t(x) = " + t.funktion_user_kurz])
# tangentengleichung zusammenbasteln
if erg_ableitung != 0:
funktionsterm = ""
if erg_ableitung < 0:
funktionsterm += "(1/" + str(erg_ableitung * -1) + ")"
elif erg_ableitung == 1:
funktionsterm += "-1"
else:
funktionsterm += "(-1/" + str(erg_ableitung) + ")"
if self.x_wert.get() != 0:
funktionsterm += " * (x" + vorzeichen_str(
self.x_wert.get() * -1) + ") "
else:
funktionsterm += " * x "
if erg_normale_funktion != 0:
funktionsterm += vorzeichen_str(erg_normale_funktion)
if funktionsterm == "":
funktionsterm = "0"
n = Funktion(self.parameter, funktionsterm)
graph_n = Graph(n, "#FFCC33", "hellgelb", "n(x)")
self.funktionen.append(graph_n)
tk.Label(self,
text="n(x) = " + n.funktion_user_kurz,
fg="green4").grid(row=9, column=1)
pdf_norm(["erg", "n(x) = " + n.funktion_user_kurz])
else:
tk.Label(
self,
text=
"Fehler durch Null teilen -> keine Normalengleichung",
fg="green4").grid(row=9, column=1)
pdf_norm([
"noerg",
"Fehler durch Null teilen -> keine Normalengleichung"
])
else:
tk.Label(self,
text="Tangentengleichung kann nicht bestimmt werden",
fg="red").grid(row=7, column=1)
tk.Label(self,
text="Normalengleichung kann nicht bestimmt werden",
fg="red").grid(row=9, column=1)
pdf_tang(
["noerg", "Tangentengleichung kann nicht bestimmt werden"])
pdf_norm(
["noerg", "Normalengleichung kann nicht bestimmt werden"])
else:
tk.Label(
self,
text="Für Tangente und Normale Funktion oben eingeben").grid(
row=0, column=0)