Seit 2002 Diskussionen rund um die Programmiersprache Python
https://www.python-forum.de/
Vielleicht verrätst Du uns erst einmal, in welchem Rahmen Dein Ableitungstool enstehen soll? Bist Du Schüler oder Student? Ist das eine freiwillige Aufgabe oder eine verpflichtende? Wie / inwelchem Umfang ist Python dort bisher vermitelt worden? Wer hat Dir diese Aufgabe erteilt? Ist das im Wissen um die Komplexität geschehen? Bist Du sicher, dass Du das wirklich universell lösen sollst?Jaga hat geschrieben:was würdet ihr mir dann raten zu tun?
Code: Alles auswählen
import matplotlib.pyplot as plt
import numpy as np
import Tkinter
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg
import parser
import re
REPLACE_DIC = {'sin' : 'np.sin',
'arcsin' : 'np.arcsin',
'sinh' : 'np.sinh',
'arcsinh' : 'np.arcsinh',
'cos' : 'np.cos',
'arccos' : 'np.arccos',
'cosh' : 'np.cosh',
'arccosh' : 'np.arccosh',
'tan' : 'np.tan',
'arctan' : 'np.arctan',
'tanh' : 'np.tanh',
'arctanh' : 'np.arctanh',
'ln' : 'np.log',
'log' : 'np.log',
'log10' : 'np.log10',
'exp' : 'np.exp',
'^' : '**',
'sqrt' : 'np.sqrt',
'pi' : 'np.pi',
}
class App():
def __init__(self, master):
self.master = master
master.protocol("WM_DELETE_WINDOW", self.ende)
self.initUI()
def ende(self):
self.master.destroy()
self.master.quit()
def initUI(self):
self.master.title("Funktionsplotter")
self.label_funktion = Tkinter.Label(self.master, text = "Funktion: f(x)")
self.label_funktion.grid(row = 0, column = 0)
self.entry_funktion = Tkinter.Entry(self.master, width = 150)
self.entry_funktion.grid(row = 0, column = 1)
self.label_startwert = Tkinter.Label(self.master, text = "Startwert der Funktion:")
self.label_startwert.grid(row = 2, column = 0)
self.entry_startwert = Tkinter.Entry(self.master, width = 15)
self.entry_startwert.grid(row = 2, column = 1)
self.label_endwert = Tkinter.Label(self.master, text = "Endwert der Funktion:")
self.label_endwert.grid(row = 3, column = 0)
self.entry_endwert = Tkinter.Entry(self.master, width = 15)
self.entry_endwert.grid(row = 3, column = 1)
self.label_genauigkeit = Tkinter.Label(self.master, text = "Abstand zwischen zu berechnenden Punkten:")
self.label_genauigkeit.grid(row = 4, column = 0)
self.entry_genauigkeit = Tkinter.Entry(self.master, width = 15)
self.entry_genauigkeit.grid(row = 4, column = 1)
self.plot_button = Tkinter.Button(self.master, text = "Funktion plotten", command = self.plot)
self.plot_button.grid(row = 0, column = 4)
self.hinzufueg_button = Tkinter.Button(self.master, text = "Zum Plot hinzufügen", command = self.hinzufuegen)
self.hinzufueg_button.grid(row = 2, column = 4)
fig = plt.figure()
self.canvas = FigureCanvasTkAgg(fig, master=self.master)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.master)
self.canvas.get_tk_widget().grid(row=5, column=1)
self.toolbar.grid(row=7, column=1)
def formel_berechnen(self,):
self.x = np.arange(float(self.entry_startwert.get()),
float(self.entry_endwert.get()),
float(self.entry_genauigkeit.get()))
x = self.x
formula_raw = self.entry_funktion.get().replace('e^x', 'exp(x)')
formula_raw_exp = formula_raw.replace('e^', 'exp')
formula_list = re.split('(\W)', formula_raw_exp)
formula_replace = [REPLACE_DIC.get(item,item) for item in formula_list]
formula_finish = ''.join(formula_replace)
form = parser.expr(formula_finish).compile()
try:
self.y = eval(form)
self.legend = self.entry_funktion.get()
except NameError:
self.y = np.sin(self.x)
self.legend = 'sin(x)'
return (self.x,self.y,self.legend)
def plot(self):
self.formel_berechnen()
plt.clf()
plt.plot(self.x,self.y, label=self.legend)
plt.grid('on')
plt.xlabel('x - Achse')
plt.ylabel('y - Achse')
plt.legend()
plt.gcf().canvas.draw()
def hinzufuegen(self):
self.formel_berechnen()
plt.plot(self.x,self.y, label=self.legend)
plt.legend()
plt.gcf().canvas.draw()
def main():
root = Tkinter.Tk()
app = App(root)
root.mainloop()
if __name__ == '__main__':
main()Code: Alles auswählen
"""
python drv.py function min_x max_x sampling
E.g.:
python drv.py "x**2" -10 10 0.1
python drv.py "sin(x) -10 10 0.1
"""
import functools
import matplotlib.pyplot as plt
import numpy as np
import sys
from collections import namedtuple
from sympy.parsing.sympy_parser import parse_expr as parse_expression
def on_mouse_move(ax, fig, data, event):
x = event.xdata
y = evaluate_at(data.expression, x)
m = evaluate_at(data.derivative, x)
ax.cla()
#plot expression and derivative
plot_graphs(ax, data.xs, data.ys_expression, data.ys_derivative)
#plot tangent
b = y - m*x
y_left = m*data.xs[0] + b
y_right = m*data.xs[-1] + b
ax.plot([data.xs[0], data.xs[-1]], [y_left, y_right], "-", color="pink")
#plot current point
ax.plot([x], [y], "o", color="green")
fig.canvas.draw()
def evaluate_at(expression, x):
return float(expression.evalf(subs={"x":x}))
def evaluate(expression, xs):
return [evaluate_at(expression, x) for x in xs]
def plot_graphs(ax, xs, ys_expression, ys_derivative):
#lilmits
ax.set_xlim([xs[0], xs[-1]])
ys = ys_expression + ys_derivative
low, high = min(ys), max(ys)
height = high - low
delta = 0.1*height
ax.set_ylim([low-delta, high+delta])
#plot
ax.plot(xs, ys_expression, "-", color="blue")
ax.plot(xs, ys_derivative, "-", color="red")
def main():
expression = sys.argv[1]
x0 = float(sys.argv[2])
xn = float(sys.argv[3])
step = float(sys.argv[4])
expression = parse_expression(expression)
derivative = expression.diff("x")
xs = np.arange(x0, xn, step)
ys_expression = evaluate(expression, xs)
ys_derivative = evaluate(derivative, xs)
#prepare plot
fig = plt.figure()
ax = fig.add_subplot(111)
#status data
Data = namedtuple(
"Data",
["expression", "derivative",
"xs", "ys_expression", "ys_derivative"])
data = Data(
expression, derivative,
xs, ys_expression, ys_derivative)
#register events
fig.canvas.mpl_connect(
"motion_notify_event",
functools.partial(
on_mouse_move, ax, fig, data))
#plot
plot_graphs(ax, xs, ys_expression, ys_derivative)
plt.show()
if __name__ == "__main__":
main()