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)