Gelöst: N-faches Integral berechnen



  • Guten Abend allerseits,

    ich stehe gerade ein wenig auf der Leitung:
    Ich möchte (in Python) ein Integral über eine Funktion mit N Argumenten bilden. Der offensichtliche Ansatz wäre also (Pseudocode):

    for x1 in Intervall_x1:
      for x2 in Intervall_x2:
        ....
          for xi in Intervall_xi:
            summe += func(x1,x2,..,xi)*dx1*dx2*..*dxi
    

    Leider weis ich nicht wieviel Parameter die Funktion besitzt. Die zweite Möglichkeit wäre per Rekursion, aber das möchte ich eigentlich vermeiden. Es gibt sicherlich einen iterativen Standardweg.

    Hat jemand eine Idee?
    Vielen Dank schonmal 🙂

    //EDIT:
    Um Missverständnisse auszuräumen: Ich weis schon wieviel Parameter die Funktion besitzt (es sind N :P), aber erst zur Laufzeit.



  • Hi,

    hast du rekursiven Beispielcode für mich?



  • Nein, aber inzwischen hab ich es hinbekommen, ist leider nicht wirklich schön geworden. Ich poste das Ergebnis mal, falls irgendwann jemand über die gleiche Sache stolpert:

    running = True
                    while True:
                            for i in range(0, len(xlow)):
                                    x[i] =  x[i] + xsteps[i]
                                    if x[i] <= xhigh[i]:
                                            break
                                    if i == len(xlow)-1:
                                            running = False
                                            break
                                    x[i] = xlow[i]
    
                            if running == False:
                                    break
                            summe = summe + self(x,p)
    

    In worten: Fange beim ersten Parameter an und erhöhe diesen bis zum oberen Limit und führe den Schleifenrumpf aus. Ist der erste Parameter über dem Limit erhöhe den zweiten und setze den ersten zurück und beginne von vorne. Tritt der Fall ein, dass der zweite Parameter ebenfalls die obere Grenze überschreitet wird der dritte erhöht und so weiter. Überschreitet der letzte Parameter die obere Grenze ist dann Schluss.

    Implementieren lässt sich dass dann wie oben gezeigt mit einer do-while schleife (in python dann leider while True:) und einer for schleife for dem eigentlichen Rumpf die die Parameter anpasst.

    Hat sich damit also erledigt 🙂



  • @Mario
    Das geht mit wenig Mehraufwand deutlich besser. Ich meine damit das prinzipielle Verfahren zur numerischen Integration was die Fehlerschranken betrifft, nicht die Art der Implementierung.

    Zum Beispiel:
    1. Newton-Cotes Quadraturformeln. (http://de.wikipedia.org/wiki/Newton-Cotes-Formeln)
    2. Gauß-Quadratur. (http://de.wikipedia.org/wiki/Gauß-Quadratur)

    Zumindest 1 lässt sich schmerzfrei und performant in höhere Dimensionen anwenden. 2 wahrscheinlich auch aber es ist zu lange her, dass ich das mal lernen musste 🙂

    Such mal nach Skripten zur Numerischen Mathematik (Integration, Quadratur). Und bei numerisch wirklich fiesen, hochdimensionalen Integranden gibt es randomisierte Algorithmen.



  • Edit: .



  • Danke für den Hinweis, da hat gerade in meinem Hinterkopf was geklingelt. Die Verfahren habe ich sogar mal implementiert (in C damals) jedoch nur in einer Dimension. Werde ich auf jeden Fall nochmal machen. Für mein jetziges Problem reicht aber der einfache Ansatz aus, da ich eine Funktionsanpassung mit der Chi^2 Methode implementieren will, das Integral dient nur zur Bestimmung von Wahrscheinlichkeiten.


Log in to reply