Breaken mehrerer Rekursioninstanzen

[SomeMathStudent]

Hey,
Im Rahmen meines Algorithmische Mathematik Moduls müssen wir mit Hilfe von Intervallschachtelung eine Funktion untersuchen, während ich den Code dafür geschrieben habe ist mir allerdings ein Problem gekommen. Mein Code sieht momentan folgendermaßen aus:

Code: Alles auswählen

import numpy as np

def func(x):
    return x

def func_deriv(x):
    return 1

def Intervalle(von,bis,res):
    if np.abs(von-bis) < 10.e-10:
        res.append(von)
        return
    if (func(von)<0 and func(bis)>=0) or (func(von)>=0 and func(bis)<0):
        Intervalle(von, (von+bis)/2,res)
        Intervalle((von+bis)/2,bis,res)
    else:
        return
    return

Das "Mitschleppen" der Liste ist aber irgendwie sehr unoptimal, lieber hätte ich den Code eher so:

Code: Alles auswählen

def Intervalle(von,bis):
    if np.abs(von-bis) < 10.e-10:
        return von
    if (func(von)<0 and func(bis)>=0) or (func(von)>=0 and func(bis)<0):
        Intervalle(von, (von+bis)/2,res)
        Intervalle((von+bis)/2,bis,res)

Jedoch wird mir dann logischerweise None ausgegeben, da ich ja nur die erste Rekursionsinstanz aufrufe.
Gibt es eine Möglichkeit, das ganze schöner zu lösen als mit der Liste ?

Vielen Dank im Voraus

[__deets__]

Immer return zu verwenden, und natürlich mit der Liste. Eine simpleres Beispiel:

Code: Alles auswählen

def listgen(n):
      if n == 0:
            return []
      return [n] + listgen(n-1)

[SomeMathStudent]

Immer return zu verwenden, und natürlich mit der Liste. Eine simpleres Beispiel:

Code: Alles auswählen

def listgen(n):
      if n == 0:
            return []
      return [n] + listgen(n-1)

Okay, aber wenn ich vor beide Aufrufe return schreibe, wird doch immer nur der erste aufgerufen, weil der return Befehl die Funktion terminiert oder ?
Sprich auf nen simples Beispiel:

Code: Alles auswählen

import numpy as np

def search1(links,rechts):
	if np.abs(links-1) < 10.e-4:
		return links
	if rechts>1 and links<1:
		return search1(links,(links+rechts)/2)
		return search1((links+rechts)/2,rechts)
print(search1(-2,2)) #gibt None
print(search1(1,2)) #gibt 1

Und wenn man das mit Listen umsetzt

Code: Alles auswählen

import numpy as np

def search1(links,rechts):
    if np.abs(links-1) < 10.e-4:
        return [links]
    if rechts>1 and links<1:
        return [] + search1(links,(links+rechts)/2)
        return [] + search1((links+rechts)/2,rechts)
    else:
        return []

print(search1(1,2)) #gibt[1]
print(search1(-2,2)) #gibt[]

Oder habe ich etwas falsch verstanden ? Mit nur einem Rekursionsaufruf pro Rekursion funktioniert das, aber wenn man 2 oder mehr aufruft nicht mehr ..

[__deets__]

Dann schreibst du eben zwei Aufrufe in die returns-Anweisung, oder Speicherst die Ergebnisse zwischen, verarbeitest sie & lieferst das Ergebnis eben dann zurück.

[__deets__]

Beispiel dafür zum nachschlagen: Fibonacci-Funktion.