>> autres langages de dév. on est obligé de s'en servir..
>> On n'est jamais obligé de s'en servir, mais cela a un avantage d'etre>> plus clair
>> En vfp on est parfois limite du au niveau des 'DO' et dans ce cas il>> faut emploer une methode iterative
>> "G.L.S" wrote in message news:iagjgr$120$1@news.niouzes.net...
>> Je rebondis sur les dires de Marc..
>> autres langages de dév. on est obligé de s'en servir..
>> news:iagieb$9b$1@news.niouzes.net...
>>> >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
>>>>>
>>>>