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.

dim. 31 octobre 2010, 17h59
eddymaue
atoutfox.public.association

Re: Récursivité et stack space

Gilles t'as raison
A part fouiner dans la profondeur des arcades de mes objets et la
recherche de fichiers sur mes disques c'est rare, voir très rare, que
je me serve de la récursivité....

humm… quoi que dans les treeviews c'est pas mauvais non plus et toutes
algorithmes qui doivent fouiller dans un arbre dont on ne connait pas
le nombre de branches ainsi que la profondeur variable de chacune ...
je ne vois pas comment autrement faire que de passer par la
récursivité…. Il y a aussi le fameux algo QuickSort qui est bel exemple
de récursivité dans le tri d’une liste d’éléments d’un tableau… J’ai
pratiqué cet algo pour la première fois sur mon Commodore 64 et comme
exercice surtout les environnements ou j’ai fait du développement.
Mais enfin pour faire 1+1=3 c’est pas utile… ;)

Bonne soirée



G.L.S avait énoncé :
> Bonjour,
>
> Merci Greg..
> en mode itératif dans une même séquence je ne vois pas comment faire...peut
> être une procédure appelante qui met dans un tableau les répertoires
> courants, les balaye un par un en appelant une fonction avec comme paramètre
> le tableau courant passé en référence, l'indice à traiter du tableau courant
> passé en valeur qui traite les fichiers du répertoire indicé et qui ajoute
> dans le tableau passé en référence les nouveaux répertoires trouvés. Ce
> tableau à l'origine possède une dimension supplémentaire pour ne plus à avoir
> à traiter les répertoires déjà balayés..
>
> Maintenant, hormis le cas d'utilisation de Eddy qui jongle avec les objets de
> VFP, je ne vois pas dans une application le besoin de balayer des répertoires
> dont on ne connait pas d'avance ni le nom du dossier principal, ni la
> structure des noms de dossiers et fichiers..D'autant que je me doute qu'une
> telle opération doit être couteuse en temps machine..
>
> Je suis obtus et pragmatique, mais la récursivité couplée a vos explications
> au demeurant brillantes et compréhensibles, me semble rester un phénomène
> théorique (dans des applications ou VFP va donner pleinement sa mesure a
> savoir le traitement des données d'une base de données à des fins de
> gestions) et ne me laisse entrevoir aucune utilisation utile dans mes
> programmes..
>
> Amicalement
> G.L.S
> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
> news:iagsmk$76c$1@news.niouzes.net...
>> Tiens, Gilles,
>>
>> Je te donne le code pour parcourir des repertoires de maniere recursive. Il
>> est assez simple
>>
>> Petit excersice : donne-moi le code pour le faire - et dans la meme
>> sequence - en mode iteratif ?
>>
>>
>> ?AdirRecursive('d:\tmp')
>>
>> function AdirRecursive(folder)
>>
>> local aa[1], i, n, mounted, filename
>>
>> n = adir(aa, addbs(m.folder) + '*.*', 'AHRDS', 1)
>> mounted = !( (m.n >= 2) and (aa[1,1]=='.') and (aa[2,1] == '..') )
>>
>> for i = iif(m.mounted, 1, 3) to m.n
>> filename = addbs(m.folder) + m.aa[m.i, 1]
>> ?m.filename
>> if( 'D' $ m.aa[m.i, 5] )
>> =AdirRecursive(m.filename)
>> endif
>> endfor
>>
>> endfunc
>>
>>
>>
>> Gregory
>> __
>> "G.L.S" wrote in message news:iagqhb$5qn$1@news.niouzes.net...
>>
>> 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=0000004304
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