ATOUTFOX
COMMUNAUTÉ FRANCOPHONE DES PROFESSIONNELS FOXPRO
Visual FoxPro : le développement durable

Forum AtoutFox : Re: Récursivité et stack space   

Sujet

rss Flux RSS des derniers messages

Vous devez vous identifier pour pouvoir poser une question ou répondre.

sam. 30 octobre 2010, 12h03
G.L.S
atoutfox.public.association

Re: Récursivité et stack space

Merci Greg..

Donc je retiens hormis la brillante démonstration que cela ne sert pas à
grand chose de pratique dans nos applications VFP sauf à améliorer
ponctuellement la lisibilité de quelques cas d'écritures..

Amicalement
G.L.S.
"Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
news:iagntr$3vj$1@news.niouzes.net...
> >surtout dans quelles situations concrètes sous VFP ou
> 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
>
>
>
> Gregory
> __
> "G.L.S" wrote in message news:iagjgr$120$1@news.niouzes.net...
>
> Bonjour,
>
> Je rebondis sur les dires de Marc..
>
> Perso je ne sais pas ce que c'est que la récursivité (bien que le mot ne
> me
> soit pas étranger) et surtout dans quelles situations concrètes sous VFP
> ou
> autres langages de dév. on est obligé de s'en servir..
>
> Cordialement
> G.L.S
> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
> 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
>>>>
>>>
Permalink : http://www.atoutfox.org/nntp.asp?ID=0000004290
20 286 messages dans le forum • Liste complète des messages

www.atoutfox.org - Site de la Communauté Francophone des Professionnels FoxPro - v3.4.0 - © 2004-2026.
Cette page est générée par un composant COM+ développé en Visual FoxPro 9.0-SP2-HF3