Das deutsche Python-Forum

Hat schonmal jemand mit hilfe von SciPy die ableitung einer Funktion berechnet? Ich werde nämlich aus den beispielen nicht ganz schlau, wie ich das machen muss.

Hoi darkfrog(??),

angenommen Du hast zwei scipy arrays (1D-Daten) x und y:

Code: Alles auswählen

#Ableitung berechnen:
dif = diff(y)
#zweite Ableitung berechnen:
dif2 = diff(dif)
#matplotlib installiert?
pylab.plot(x,y,'k-') #Rohdaten
pylab.plot(x,dif,'g-') #1.Ableitung
pylab.plot(x,dif2,'r-) #2.Ableitung

Alles klar?

Gruß,
Christian

Oh, sorry, Du meintest eine Funktion? Was ist damit gemeint: Ein Polynom?

Tut mir leid, wahrscheinlich habe ich die falsche Antwort geliefert, aber bevor ich und andere jetzt rumraten: Ein kurzes Beispiel bitte.

Gruß,
Christian

für was benötigt man ableitungen von arraywerten? was bekommt man da für ergebnisse?

ich meinte wirklich die erste oder zweite ableitung einer Funktion. Also das Thema, mit der sich die Differentialrechnung beschäftigt.
geht das überhaupt mit scipy? Oder sollte man das über ein Computer Algebra System wie Maxima machen?

Danke für die schnelle Antwort. Ich lese schon seit längerer zeit hier das Forum und hab mich jetzt selbst angemeldet, is echt super!!!

darkfrog hat geschrieben:geht das überhaupt mit scipy? Oder sollte man das über ein Computer Algebra System wie Maxima machen?

Wohl nicht direkt. Und ja, für analytische Lösungen sind CAS besser geeignet.

Hoi,

Joghurt hat geschrieben:Wohl nicht direkt.

Und wieso nicht? Bei einfachen Polynomen ist das kein Problem:

Code: Alles auswählen

>>> import scipy
>>> a = scipy.poly1d([2,3,4])
>>> print a
   2
2 x + 3 x + 4
>>> print a*a
   4      3      2
4 x + 12 x + 25 x + 24 x + 16
>>> print a.integ.__doc__
Return the mth analytical integral of this polynomial.
        See the documentation for polyint.
>>> print scipy.polyint.__doc__
Return the mth analytical integral of the polynomial p.

    If k is None, then zero-valued constants of integration are used.
    otherwise, k should be a list of length m (or a scalar if m=1) to
    represent the constants of integration to use for each integration
    (starting with k[0])
>>> print a.integ(k=6)
        3       2
0.6667 x + 1.5 x + 4 x + 6
>>> print a.deriv.__doc__
Return the mth derivative of this polynomial.
>>> print a.deriv()

4 x + 3

Steht (fast genau so) im Tutorial, daß man sich runterladen kann. Allerdings gebe ich zu, daß für das Spielen mit Funktionen - sprich, wenn man nicht wirklich Daten zu prozessieren hat - oder wenn man schnell mal was überschlagen will, andere Software besser geeignet ist. Außerdem ist Scipy im Umgang mit komplizierteren Funktionen etwas umständlich.

@darkfrog: Verstehe nicht wie die Frage nach der "Ableitung von Arraywerten" gemeint ist.

Gruß,
Christian

@CM
in deinem ersten Beitrag oben hast du ja ein Stück code.
Ich wollte eigentlich nur wissen, was der macht und was dabei der Bergriff Ableitung bedeutet.

Danke für die Antworten: Ich dachte zwar das ich irgendwo auf der seite von Scipy was von Funktionsabletitungen gelesen habe, vielleicht hab ich mich aber auch nur getäuscht.

Mit Maxima funktioniert es prima, aber wie bekomm ich die Ergebnisse der Befehle, die ich an Maxima mit os.system übergegen hab wieder zurück in mein Python Programm?

Du könntest das Ergebnis in Maxima zum Beispiel mit der `stringout()` Funktion in eine Datei schreiben. Oder das `subprocess` Modul benutzen und die Ausgabe auslesen, die sonst auf der Konsole landen würde.

Könntest Du denn mal ein Beispiel geben was Du hast (Funktion) und was Du haben möchtest (Ableitung) und wie Du das bis jetzt (teilweise) löst?

Beispielsweise habe ich die Funktion:
f(x) = 1/8*x^3+3/8*x^2-9/8*x-3/8
dann ist die erste Ableitung:
f'(x) = 3/8*x^2+3/4x-9/8
und die zweite:
f''(x) = 3/4*x+3/4

Bisher nehme ich einen Funktionstherm in obriger Form vom Benutzter entgegen, reiche in an Maxima weiter und lasse in halt differenzieren.
jetzt hätte ich halt gern die Ableitungen wieder zurück im Python-Programm

Oops. Blödsinn geschrieben

So als Ausgangspunkt:

Code: Alles auswählen

from string import Template
from subprocess import Popen, PIPE, STDOUT


def diff(func, var):
    def output_filter(line):
        return line.startswith('(%o')
    
    def strip_output(line):
        return line.split(None, 1)[1].strip()
    
    maxima_program = Template('$func $$'
                              ' diff(%o1, $var)$$'
                              ' diff(diff(%o1, $var), $var)$$'
                              ' string(%o2);'
                              ' string(%o3);')
    maxima_pipe = Popen(('maxima',
                         '--batch-string',
                         maxima_program.substitute(locals())),
                        stdout=PIPE,
                        stderr=STDOUT)
    result = filter(output_filter, maxima_pipe.stdout)
    maxima_pipe.wait()
    return map(strip_output, result)

print diff('1/8*x^3+3/8*x^2-9/8*x-3/8', 'x')

Wenn die Eingabe vom Benutzer kommt, dann muss man natürlich noch auf Fehler reagieren.

Falls die Funktionen immer so aussehen, also einfach nur Polynome sind, dann kann man sich aber auch überlegen den Code zur Ableitung in Python zu schreiben.

vielen dank, klappt prima
hab den Code etwas für meine zwecke überarbeitet und muss ein paar dumme anfängerfragen stellen:
- result = filter(output_filter, maxima_pipe.stdout) : Was macht die Funktion filter?
- return map(strip_output, result) : was macht hier das map?
- return line.split(None, 1)[1].strip() : was machen hier die übergebenen Parameter?

ich weiß, blöde fragen, bin aber erst seit kurzem bei python, habe davor nur in c++ und php programmiert. Bin aber von python sehr begeistert!!!!

darkfrog hat geschrieben:- result = filter(output_filter, maxima_pipe.stdout) : Was macht die Funktion filter?

help(filter) hat geschrieben:filter(...)
filter(function or None, sequence) -> list, tuple, or string

Return those items of sequence for which function(item) is true. If
function is None, return the items that are true. If sequence is a tuple
or string, return the same type, else return a list.

Also sie filtert alle Items heraus, die der gegebenen Bedingung nicht entsprechen. Nett für funktionale Programmierung in Python.

darkfrog hat geschrieben:- return map(strip_output, result) : was macht hier das map?

help(map) hat geschrieben:map(...)
map(function, sequence[, sequence, ...]) -> list

Return a list of the results of applying the function to the items of
the argument sequence(s). If more than one sequence is given, the
function is called with an argument list consisting of the corresponding
item of each sequence, substituting None for missing values when not all
sequences have the same length. If the function is None, return a list of
the items of the sequence (or a list of tuples if more than one sequence).

map ruft die als erstes Argument angegebene Funktion mit allen Items der als zweiten Argument Liste auf. Auch wieder funktionale Programmirung.

Wenn du willst, kann ich dir kurze Beispiele posten - oder du testest es selbst im Interpreter aus.

darkfrog hat geschrieben:- result = filter(output_filter, maxima_pipe.stdout) : Was macht die Funktion filter?

Die erstellt eine Liste. Das erste Argument ist eine Funktion die auf jedes Element im zweiten Argument angewendet wird. Wenn die Funktion `True` zurückgibt, dann ist das Element in der Ergebnisliste, sonst nicht. In PHP gibt's für so etwas `array_filter()` und `remove_copy_if()` in der STL (`algorithm`) für C++.

- return map(strip_output, result) : was macht hier das map?

Das erzeugt auch wieder eine neue Liste und zwar in dem es die angegebene Funktion auf jedes Element des zweiten Arguments anwendet. Vergleichbar mit `array_map()` in PHP oder der `transform()` Funktion aus der STL (`algorithm`) bei C++.

- return line.split(None, 1)[1].strip() : was machen hier die übergebenen Parameter?

`line` ist ja eine der gewünschten Ausgabezeilen von Maxima. Erst wird diese Zeile an "Whitespace" Zeichen maximal einmal gesplittet (split(None, 1)) und davon dann der zweite Teil genommen ([1]) und davon dann noch führende und nachfolgende "Whitespace" Zeichen entfernt. So etwas kann man im interaktiven Interpreter immer ganz gut ausprobieren:

Code: Alles auswählen

In [43]: line = '(%o4)                          3*x^2/8+3*x/4-9/8\n'

In [44]: line.split(None, 1)
Out[44]: ['(%o4)', '3*x^2/8+3*x/4-9/8\n']

In [45]: line.split(None, 1)[1]
Out[45]: '3*x^2/8+3*x/4-9/8\n'

In [46]: line.split(None, 1)[1].strip()
Out[46]: '3*x^2/8+3*x/4-9/8'

(Ups, etwas verspätet -- hab heute nachmittag vergessen es zu posten)

vielen dank
was lerne ich daraus: immer erst selber mit "help()" nachschauen was ein befehl macht!

Danke für eure Hilfe

Hoi darkfrog,

tut mir leid, daß ich erst jetzt antworte ...

darkfrog hat geschrieben:@CM
in deinem ersten Beitrag oben hast du ja ein Stück code.
Ich wollte eigentlich nur wissen, was der macht und was dabei der Bergriff Ableitung bedeutet.

Na, Ableitung halt. Wie wäre es Du generierst einmal ein array und testest das Beispiel? Was Du erhalten wirst ist der Wert Ableitung für jedes Intervall im array. Das kann in der Numerik ganz praktisch sein. Wenn es Dir in einem konkreten Fall nicht präzise genug ist, kannst du interpolieren und danach ableiten. - Aber Vorsicht: Oft erhält man so allenfalls scheinbare zusätzliche Präzesion.

darkfrog hat geschrieben: Danke für die Antworten: Ich dachte zwar das ich irgendwo auf der seite von Scipy was von Funktionsabletitungen gelesen habe, vielleicht hab ich mich aber auch nur getäuscht.

Geht doch auch - alles was Du möchtest geht auch mit scipy. Jedenfalls wenn ich nicht einen wesentlichen Teil übersehen habe. Allerdings vielleicht nicht so "schön" wie mit Maxima und man soll ja die Software wählen, die eher tut, was man eigentlich möchte und wenn Du Deine Wahl schon getroffen hast, ist das ja auch gut.
Jedenfalls vielen Dank für die Info zu "Maxima" - das war für mich neu.

Gruß,
Christian

Das deutsche Python-Forum

Ableitung mit SciPy

Ableitung mit SciPy