sam. 30 octobre 2010, 09h47
Gregory Adam
atoutfox.public.association
Re: Récursivité et stack space
>le vin aurait été banni au profit de
Oui, Marc, mais puisque je m'adressais a un Francais, je me disais que le
vin, il comprendrait mieux
> J'espère bien de ta part un exposé sur la récursivité dans VFP ...
Qu'entends-tu par cela ? Quels points sont obscurs ?
Gregory
__
"Marc Thivolle" wrote in message news:iaf9o5$2fh5$1@news.niouzes.net...
A part que je suis d'accord avec tes remarques techniques, je pensais que
venant de ta part le vin aurait été banni au profit de le bière et du whisky
(ce qu'on peut être méchant à 22h00 !).
Tout cela en toute amitié.
J'espère bien de ta part un exposé sur la récursivité dans VFP ... car
j'avoue que certains comportements de notre langage préféré me semblent bien
étranges.
Marc de la Bastille
"Gregory Adam" a écrit dans le message de groupe de discussion :
iaedah$1rv7$1@news.niouzes.net...
Luc,
Les stack et les queue - c'est comme le vin - il faut apprendre a apprecier
Sans doute que ton code recursif peut etre converti en non-recursif - avec
ou sans stack/queue
Faudrait voir le code pour avoir une idee
Mais - duplication du code - j'eviterais
Gregory
__
"luc Gilot" wrote in message news:iaebjt$1qp4$1@news.niouzes.net...
Merci Grégory
Bon, je connaissais bien stacks et queu, mais je ne voyais pas le rapport.
Je ne le vois toujours pas d'ailleurs, mais j'ai fini par contourner le
problème en créant une pseudo-récursivité à l'intérieur de la fonction
récursive, par duplication du code (10 fois, ce qui me permet de diviser par
10 la profondeur des appels de fonctions). Ce n'est pas très élégant mais ca
a l'air de fonctionner...
Luc
"Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de news:
iae7n8$1nv8$1@news.niouzes.net...
> Stack/Queue = pile ou on peut sauver son contexte pour le recharger apres
>
> Stack = LIFO
http://en.wikipedia.org/wiki/Stack_(data_structure)
> Queue = FIFO
http://en.wikipedia.org/wiki/Queue_(data_structure)
>
> Stack: operations:
> - Push(xx)
> - Pop(@m.xx) or Pop()
>
> Queue: operations
> - Enqueue(item)
> - Dequeue(@m.item)
>
> Une implementation simple des deux
>
> local stackObj
>
> stackObj = createObject('Stack')
> ?m.stackObj.Push(1)
> ?m.stackObj.Push(2)
> ?m.stackObj.Push(3)
> ?m.stackObj.Push(4)
>
> local x
> ?m.stackObj.Pop(@m.x)
> ?x && 4
>
> ?m.stackObj.Pop(@m.x)
> ?x && 3
>
> ?m.stackObj.Pop(@m.x)
> ?x && 2
>
> ?m.stackObj.Pop(@m.x)
> ?x && 1
>
> meme excersice avec Queue
>
>
> local queueObj
> queueObj = createObject('Queue')
> ?m.queueObj.Enqueue(1)
> ?m.queueObj.Enqueue(2)
> ?m.queueObj.Enqueue(3)
> ?m.queueObj.Enqueue(4)
>
> ?m.queueObj.Dequeue(@m.x)
> ?x && 1
>
> ?m.queueObj.Dequeue(@m.x)
> ?x && 2
>
> ?m.queueObj.Dequeue(@m.x)
> ?x && 3
>
> ?m.queueObj.Dequeue(@m.x)
> ?x && 4
>
> *===============================================================================
> *===============================================================================
> *===============================================================================
> define class Stack as CollectionBase
>
> *-------------------------------------------------------------------------------
> function Push(v)
> =m.this.Add(m.v)
> endfunc
> *-------------------------------------------------------------------------------
> function Pop(v)
>
> if( empty(m.this.Count) )
> return FALSE
> endif
> v = m.this.Item(m.this.Count)
> =m.this.Remove(m.this.Count)
>
> endfunc
> *-------------------------------------------------------------------------------
> function Peek(v)
>
> if( empty(m.this.Count) )
> return FALSE
> endif
> v = m.this.Item(m.this.Count)
>
> endfunc
> *-------------------------------------------------------------------------------
> *-------------------------------------------------------------------------------
> enddefine
> *===============================================================================
> *===============================================================================
> *===============================================================================
>
>
> *===============================================================================
> *===============================================================================
> *===============================================================================
> define class Queue as CollectionBase
>
> *-------------------------------------------------------------------------------
> function EnQueue(v)
> =m.this.Add(m.v)
> endfunc
> *-------------------------------------------------------------------------------
> function DeQueue(v)
>
> if( empty(m.this.Count) )
> return FALSE
> endif
> v = m.this.Item(1)
> =m.this.Remove(1)
>
> endfunc
> *-------------------------------------------------------------------------------
> function Peek(v)
>
> if( empty(m.this.Count) )
> return FALSE
> endif
> v = m.this.Item(1)
>
> endfunc
> *-------------------------------------------------------------------------------
> enddefine
> *===============================================================================
> *===============================================================================
> *===============================================================================
>
> *===============================================================================
> *===============================================================================
> *===============================================================================
> define class CollectionBase as Collection
>
> *-------------------------------------------------------------------------------
> function Clear()
>
> =m.this.Remove(-1)
>
> endfunc
> *-------------------------------------------------------------------------------
> function Empty()
>
> return empty(m.this.Count)
>
> endfunc
> *-------------------------------------------------------------------------------
> enddefine
>
> *===============================================================================
> *===============================================================================
> *===============================================================================
>
> Gregory
> __
> "luc Gilot" wrote in message news:iae653$1mri$1@news.niouzes.net...
>
> Merci pour vos réponses.
>
> * Changer le nb de variables ne change rien (non plus que de diminuer la
> longueur de leurs noms ou de celui de la fonction récursive : il fallait
> quand même essayer...)
>
> * Grégory qu'est-ce qu'un stack ou queue ?
>
> Luc
>
> "luc Gilot" <luc.gilot@limoog.net> a écrit dans le message de news:
> iae0jb$1ivi$1@news.niouzes.net...
>> Bonjour
>>
>> Je dois écrire un programme très récursif (environ 2000 niveaux de
>> profondeur).
>> Un premier réglage de STACKSIZE = ... dans config.fpw m'a permis d'éviter
>> le message "Trop de DO imbriqués" à une profondeur de 119.
>> J'arrive maintenant à une profondeur de 437 avec un message "Espace pile
>> insiffisant"
>>
>> Comment augmenter la taille de la pile, ou faire en sorte qu'elle se
>> remplisse moins vite (à part en ne faisant plus de récursivité!) ?
>>
>> Luc
>>
>
Permalink : http://www.atoutfox.org/nntp.asp?ID=0000004286