AW: Rekursion ist doch was feines.
 

Gibt es überhaupt "einen" Gott :rolleyes: ;)

AW: Rekursion ist doch was feines.
 

[QUOTE=Cool Master]Gibt es überhaupt "einen" Gott :rolleyes: ;)[/QUOTE]
Auf diese Frage lautet die Antwort "NEIN"! :-D

@kerri, mein Respekt!

AW: Rekursion ist doch was feines.
 

[QUOTE=10tacle]Auf diese Frage lautet die Antwort "NEIN"! :-D
[/QUOTE]

Kannst du es beweisen??? :-)
Ok, lassen wir das Thema, das gab es hier schon zur genüge...

AW: Rekursion ist doch was feines.
 

[quote]WINE = WINE Is Not an Emulator[/quote]
WINE ist doch aber eher WinE (Windows Emulation)... Das mit dem Stein iss gut. :inflames: Eigentlich keine Rekursion aber ne tolle philosophische Fragestellung.

AW: Rekursion ist doch was feines.
 

[QUOTE=Qndre]Ist der Satz wahr oder unwahr? Um die Rekursion zu verstehen muss man erst einmal die Rekursion verstehen. :wink: Definition des Begriffes Rekursion: Siehe Rekursion.

Das ist kein :spam: ! Denkt einfach mal ein wenig drüber nach... :?[/QUOTE]

also wenn der Satz wahr ist, dann ist er auch unwahr und somit hätte man mit einem Rechner ein Problem, weil man sich ne tolle Endlosschleife gebaut hat, Oder?

AW: Rekursion ist doch was feines.
 

[QUOTE=HyperY2K]also wenn der Satz wahr ist, dann ist er auch unwahr und somit hätte man mit einem Rechner ein Problem, weil man sich ne tolle Endlosschleife gebaut hat, Oder?[/QUOTE]

Zu einer richtig programmierten Rekursion gehört auch immer eine Abbruchbedingung die immer in einer endlichen Zeit erreicht werden muss (nachweisbar über Vollständige Induktion).
An sonsten hast du dir, wie du richtig festgestellt hast, eine Endlosschleife gebaut.

AW: Rekursion ist doch was feines.
 

[QUOTE=EoN]Zu einer richtig programmierten Rekursion gehört auch immer eine Abbruchbedingung die immer in einer endlichen Zeit erreicht werden muss (nachweisbar über Vollständige Induktion).
An sonsten hast du dir, wie du richtig festgestellt hast, eine Endlosschleife gebaut.[/QUOTE]

Wie wärs: Machen wir ne VI mal im Forum zusammen...

AW: Rekursion ist doch was feines.
 

Das will ich mal sehen, wie du eine unendlich laufende Rekursion hinkriegst.:mrgreen:

AW: Rekursion ist doch was feines.
 

[QUOTE=Shadow2000]Das will ich mal sehen, wie du eine unendlich laufende Rekursion hinkriegst.:mrgreen:[/QUOTE]

:gruebel:

wie soll man das denn verstehen?

sollte doch ganz einfach sein (in C):

[CODE]void bla();

int main()
{
bla();
return 0;
}

void bla()
{
bla();
}
[/CODE]



ansonsten hat EON natürlich recht und jeder halbwegs intelligente Programmierer wird da ne Abbruchbedingung setzen ;)

allerdings war das ne "programmierte" unendliche laufende Rekursion, ob man sowas auch in nem einfachen Satz hinkriegt, weiss ich ned :D

btw:
was ist "VI"?
--> steh da grad aufm Schlauch

AW: Rekursion ist doch was feines.
 

Und wo soll der unendliche Stackplatz für eine unendliche Rekursion herkommen.:mrgreen:

AW: Rekursion ist doch was feines.
 

[QUOTE=Jlagreen]:gruebel:

wie soll man das denn verstehen?

sollte doch ganz einfach sein (in C):

void bla();

int main()
{
void bla ()
{
bla();
}
}

ansonsten hat EON natürlich recht und jeder halbwegs intelligente Programmierer wird da ne Abbruchbedingung setzen ;)

allerdings war das ne "programmierte" unendliche laufende Rekursion, ob man sowas auch in nem einfachen Satz hinkriegt, weiss ich ned :D

btw:
was ist "VI"?
--> steh da grad aufm Schlauch[/QUOTE]

BTW: dein prog geht nicht.....
du kannste funktionen nur ausserhalb von main anlegen:


[CODE]
int test(void)
{
test();
return 0;
}

int main(void)
{
test();
return 0;
}


VI = Vollständige Induktion

[/CODE]

AW: Rekursion ist doch was feines.
 

Und selbige am besten noch aufrufen.

Wenn du die Funktionsdefinition und den Prototyp vertauschst, gehts sogar ohne das man nur ein weiteres Zeichen einfügen musst.:inflames:

AW: Rekursion ist doch was feines.
 

[QUOTE=HyperY2K]BTW: dein prog geht nicht.....
du kannste funktionen nur ausserhalb von main anlegen:

[/QUOTE]

jepp stimmt, aber ich wollts jetzt auch ned so genau nehmen :lol:, eigentlich wollte ich die main Funktion gar nicht schreiben und nur eine Funktion, die sich selbst aufruft, habe aber im nachhinein ohne nachzudenken schnell noch main geschrieben, aber ich denke mal, dass die Intension durchgedrungen ist ;)

naja auf nen VI hätte ich jetzt keine Lust, da ich sowas schon ne Weile nicht mehr gemacht hab :D

EDIT:
btw hab mein Beispiel "verbessert", so stimmts doch nun oder?

AW: Rekursion ist doch was feines.
 

Dann kompilier das mal und lasses laufen, sehr lange wird der nicht laufen :mrgreen:

AW: Rekursion ist doch was feines.
 

[QUOTE=Shadow2000]Dann kompilier das mal und lasses laufen, sehr lange wird der nicht laufen :mrgreen:[/QUOTE]
jepp, entweder bekommst du ne fehlermeldung oder dein os schmiert ab..

AW: Rekursion ist doch was feines.
 

Hab das grad mal mit einem int als Parameter probiert. Der Stack hat grad mal für 4788 Rekursinen gereicht :D.

Das gibt aber nur im Debug-Modus nen Fehler, beim normalen lauf bricht er einfach Fehler- und Exceptionlos ab.

AW: Rekursion ist doch was feines.
 

Klar, in C gehts nicht, weil irgendwann die Variablen überlaufen, aber in Funktionaler Programmierung ists eigentlich ganz einfach. Hier mal das ganze in Haskell als Beispiel:
[code]unendlich :: Int -> Int
unendlich x = unendlich x[/code]

Und wenn der PC nicht gestorben ist, dann rechnet er noch heute ;)

AW: Rekursion ist doch was feines.
 

warum soll rekursion in C net gehen? in haskell könnte es daran liegen, dass rekursion das einzige ist was es gibt, oder gibs da schon schleifen?

AW: Rekursion ist doch was feines.
 

[QUOTE=tele]warum soll rekursion in C net gehen? in haskell könnte es daran liegen, dass rekursion das einzige ist was es gibt, oder gibs da schon schleifen?[/QUOTE]

ich denke EON hat ihr eher die "unendlich laufende Rekursion" gemeint, da in C schnell der Stack zb. zu Ende geht

Rekursion selbst geht in C natürlich einwandfrei (wäre ja auch schlimm, wenn nicht) :)

AW: Rekursion ist doch was feines.
 

[QUOTE=tele]warum soll rekursion in C net gehen? in haskell könnte es daran liegen, dass rekursion das einzige ist was es gibt, oder gibs da schon schleifen?[/QUOTE]Nein es gibt keine Schleifen. Das würde aber auch den Sinn der funktionalen Programmierung ad absurdum führen, da dort nur Ausdrücke ausgewertet werden.

[QUOTE=Jlagreen]ich denke EON hat ihr eher die "unendlich laufende Rekursion" gemeint, da in C schnell der Stack zb. zu Ende geht[/QUOTE]Das ist ja das tolle in Haskell, es gibt keine wirklichen Stack/Variablenbeschränkungen, da die Programmiersprache nicht so sehr Maschinennah ist wie C.
Man kann z.B. unendlich lange Listen definieren. Genügend Arbeitsspeicher vorrausgesetzt, sind genau so unendlich große Variablen möglich.

Daher funktioniert dann die Rekursion auch "unendlich" oft und wird nicht (so sehr) durch Maschinenbeschränkungen eingeschränkt.
Wobei ich auch sagen muss, dass bei mir mit gcc 126 594 Rekursionen möglich sind, bevor das Programm abbricht. Für den Hausgebrauch dürfte das normalerweise ausreichen ;)

AW: Rekursion ist doch was feines.
 

[QUOTE=EoN][...]
Wobei ich auch sagen muss, dass bei mir mit gcc 126 594 Rekursionen möglich sind, bevor das Programm abbricht. Für den Hausgebrauch dürfte das normalerweise ausreichen ;)[/QUOTE]

Wie messt Ihr das? Ich habs einfach mal laufen lassen, mit ner print anweisung, die alle 10000 rekursionen mal 'piep' sagt, also so:
[code]
void bla()
{
i++;
if (i%10000 == 0)
printf("rekursion nr %d\n",i);
bla();
}
[/code]

und das muellte mir rasend schnell (in etwa 2 Minuten) den Speicher (incl SWAP insgesamt etwa 800MB waren frei) zu, und das Ende vom Lied war dann, das fast ueberhaupt nix mehr reagierte (Ctrl+C hat nach 2 Minuten angesprochen) und die letzten Zeilen waren:

[code]
[...]
rekursion nr 61810000
rekursion nr 61820000
rekursion nr 61830000
rekursion nr 61840000
rekursion nr 61850000
rekursion nr 61860000
rekursion nr 61870000
rekursion nr 61880000
cccbash: [5474: 1] tcsetattr: Interrupted system call
Terminated

[/code]


Also sollte er fast 62 Millionen rekursionen geschafft haben? Kann man das noch anders ermittlen?

Gruesse, kerri

PS.: so langsam macht der Thread ja Sinn *staun*

AW: Rekursion ist doch was feines.
 

Interessant wie unterschiedlich das die Compiler handhaben.

Ausgabe von deiner Funktion:[code]C:\Dokumente und Einstellungen\XXX\Desktop>test
rekursion nr 10000
rekursion nr 20000
rekursion nr 30000
rekursion nr 40000
rekursion nr 50000
rekursion nr 60000
rekursion nr 70000
rekursion nr 80000
rekursion nr 90000
rekursion nr 100000
rekursion nr 110000
rekursion nr 120000

C:\Dokumente und Einstellungen\XXX\Desktop>[/code]

Mein Programmcode sieht so aus:[code]#include <stdio.h>

void bla();

unsigned int i;
int main()
{
i = 0;
bla();
printf("%i\n", i);
return 0;
}

/*void bla()
{
i++;
printf("%i\n", i);
bla();
}*/

void bla()
{
i++;
if (i%10000 == 0)
printf("rekursion nr %d\n",i);
bla();
}[/code]

Compiliert mit gcc aus cygwin.

AW: Rekursion ist doch was feines.
 

Ok, naechste Version, diesmal mit uebergabe der Variablen:

[code]
#include <stdio.h>

void bla(unsigned int i);

int main()
{
unsigned int i=0;
bla(i);
return 0;
}

void bla(unsigned int i)
{
i++;
if (i%10000 == 0) printf("rekursion nr %d\n",i);
bla(i);
}
[/code]

Ausgabe diesmal:
[code]
[...]
rekursion nr 30940000
rekursion nr 30950000
rekursion nr 30960000
rekursion nr 30970000

kerri@assam:~>
[/code]

Hm, nur 31 mille :( muellt nicht ganz so effektiv den Speicher zu, wie die andere Version :D Aber hat sich dafuer auch etwas friedlicher beendet ;)

Wobei ich es eigentlich erstaunlich finde, das sich die Kiste hinterher wieder faengt.

Gruesse, kerri

EDIT:
kerri@assam:~> gcc --version
gcc (GCC) 3.3.3 (SuSE Linux)

AW: Rekursion ist doch was feines.
 

Komme mit beiden Versionen auf 130k.

AW: Rekursion ist doch was feines.
 

Hm.. wirklich interessant. Anscheinend ist der Windowsport von gcc nicht mal halb so mächtig wie die original Linuxversion:

$ gcc --version
gcc (GCC) 3.3.3 (cygwin special)

PS: Mit der Variablenübergabe, bekomm ich genau die gleichen Ergebnisse wie ohne.